@famgia/omnify-gui 1.0.0

package/dist/server/index.js

@@ -0,0 +1,1087 @@
+#!/usr/bin/env node
+
+// src/server/index.ts
+import { createServer } from "http";
+import { join as join3 } from "path";
+import open from "open";
+
+// src/server/app.ts
+import express from "express";
+import { fileURLToPath } from "url";
+import { dirname, join as join2 } from "path";
+
+// src/server/api/schemas.ts
+import { Router } from "express";
+
+// src/server/services/schemaService.ts
+import { loadSchemas } from "@famgia/omnify-core";
+import { writeFile, unlink } from "fs/promises";
+import { join } from "path";
+import { stringify } from "yaml";
+function normalizeEnumValues(values) {
+  if (!values || !Array.isArray(values)) return void 0;
+  return values.map((v) => {
+    if (typeof v === "object" && v !== null && "value" in v) {
+      const obj = v;
+      return {
+        value: String(obj.value),
+        label: obj.label ? String(obj.label) : void 0,
+        extra: obj.extra
+      };
+    }
+    return { value: String(v) };
+  });
+}
+var SchemaService = class {
+  cache = /* @__PURE__ */ new Map();
+  async loadAll(schemasDir2) {
+    try {
+      const schemas = await loadSchemas(schemasDir2);
+      const guiSchemas = {};
+      for (const [name, schema] of Object.entries(schemas)) {
+        guiSchemas[name] = {
+          name: schema.name,
+          kind: schema.kind ?? "object",
+          displayName: schema.displayName,
+          filePath: schema.filePath,
+          relativePath: schema.relativePath,
+          properties: schema.properties,
+          options: schema.options,
+          values: normalizeEnumValues(schema.values),
+          isDirty: false,
+          validationErrors: []
+        };
+      }
+      this.cache.set(schemasDir2, guiSchemas);
+      return guiSchemas;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return {};
+      }
+      throw error;
+    }
+  }
+  async load(schemasDir2, name) {
+    const schemas = await this.loadAll(schemasDir2);
+    return schemas[name] ?? null;
+  }
+  async save(schemasDir2, schema) {
+    const { isDirty: _isDirty, validationErrors: _validationErrors, filePath: _filePath, ...schemaData } = schema;
+    const fileName = `${schema.name}.yaml`;
+    const targetPath = join(schemasDir2, fileName);
+    const yamlContent = stringify(schemaData, {
+      lineWidth: 120,
+      defaultKeyType: "PLAIN",
+      defaultStringType: "PLAIN"
+    });
+    await writeFile(targetPath, yamlContent, "utf-8");
+    return {
+      ...schemaData,
+      filePath: targetPath,
+      isDirty: false,
+      validationErrors: []
+    };
+  }
+  async delete(schemasDir2, name) {
+    const fileName = `${name}.yaml`;
+    const targetPath = join(schemasDir2, fileName);
+    await unlink(targetPath);
+    this.cache.delete(schemasDir2);
+  }
+  clearCache(schemasDir2) {
+    if (schemasDir2) {
+      this.cache.delete(schemasDir2);
+    } else {
+      this.cache.clear();
+    }
+  }
+};
+var schemaService = new SchemaService();
+
+// src/server/api/schemas.ts
+var schemasRouter = Router();
+schemasRouter.get("/", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const schemas = await schemaService.loadAll(config.schemasDir);
+    const response = {
+      success: true,
+      data: schemas
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "LOAD_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+schemasRouter.get("/:name", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const { name } = req.params;
+    const schema = await schemaService.load(config.schemasDir, name);
+    if (!schema) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `Schema "${name}" not found`
+        }
+      };
+      res.status(404).json(response2);
+      return;
+    }
+    const response = {
+      success: true,
+      data: schema
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "LOAD_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+schemasRouter.post("/", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const schema = req.body;
+    if (!schema.name) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: "Schema name is required"
+        }
+      };
+      res.status(400).json(response2);
+      return;
+    }
+    const saved = await schemaService.save(config.schemasDir, schema);
+    const response = {
+      success: true,
+      data: saved
+    };
+    res.status(201).json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "SAVE_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+schemasRouter.put("/:name", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const { name } = req.params;
+    const schema = req.body;
+    schema.name = name;
+    const saved = await schemaService.save(config.schemasDir, schema);
+    const response = {
+      success: true,
+      data: saved
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "SAVE_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+schemasRouter.delete("/:name", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const { name } = req.params;
+    await schemaService.delete(config.schemasDir, name);
+    const response = {
+      success: true
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "DELETE_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+
+// src/server/api/validate.ts
+import { Router as Router2 } from "express";
+
+// src/server/services/validationService.ts
+import { loadSchemas as loadSchemas2, validateSchemas } from "@famgia/omnify-core";
+function toLoadedSchema(schema) {
+  const result = {
+    name: schema.name,
+    kind: schema.kind,
+    filePath: schema.filePath,
+    relativePath: schema.relativePath ?? schema.name + ".yaml"
+  };
+  if (schema.displayName !== void 0) {
+    result.displayName = schema.displayName;
+  }
+  if (schema.properties !== void 0) {
+    result.properties = schema.properties;
+  }
+  if (schema.options !== void 0) {
+    result.options = schema.options;
+  }
+  if (schema.values !== void 0) {
+    result.values = schema.values;
+  }
+  return result;
+}
+var ValidationService = class {
+  async validateSchema(schema, schemasDir2) {
+    try {
+      const allSchemas = await loadSchemas2(schemasDir2);
+      const loadedSchema = toLoadedSchema(schema);
+      const schemasToValidate = { ...allSchemas };
+      schemasToValidate[schema.name] = loadedSchema;
+      const result = validateSchemas(schemasToValidate);
+      const schemaResult = result.schemas.find((s) => s.schemaName === schema.name);
+      const schemaErrors = [];
+      if (schemaResult) {
+        for (const e of schemaResult.errors) {
+          schemaErrors.push({
+            path: this.getErrorPath(e, schema.name),
+            message: e.message,
+            severity: "error"
+          });
+        }
+      }
+      return {
+        valid: schemaErrors.length === 0,
+        errors: schemaErrors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: schema.name,
+            message: error.message,
+            severity: "error"
+          }
+        ]
+      };
+    }
+  }
+  async validateAll(schemas) {
+    try {
+      const loadedSchemas = {};
+      for (const [name, schema] of Object.entries(schemas)) {
+        loadedSchemas[name] = toLoadedSchema(schema);
+      }
+      const result = validateSchemas(loadedSchemas);
+      const errors = [];
+      for (const schemaResult of result.schemas) {
+        for (const e of schemaResult.errors) {
+          errors.push({
+            path: this.getErrorPath(e, schemaResult.schemaName),
+            message: e.message,
+            severity: "error"
+          });
+        }
+      }
+      return {
+        valid: result.valid,
+        errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "root",
+            message: error.message,
+            severity: "error"
+          }
+        ]
+      };
+    }
+  }
+  async validateFromDisk(schemasDir2) {
+    try {
+      const schemas = await loadSchemas2(schemasDir2);
+      const guiSchemas = {};
+      for (const [name, schema] of Object.entries(schemas)) {
+        guiSchemas[name] = {
+          name: schema.name,
+          kind: schema.kind ?? "object",
+          displayName: schema.displayName,
+          filePath: schema.filePath,
+          relativePath: schema.relativePath,
+          properties: schema.properties,
+          options: schema.options,
+          values: schema.values
+        };
+      }
+      return this.validateAll(guiSchemas);
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "root",
+            message: error.message,
+            severity: "error"
+          }
+        ]
+      };
+    }
+  }
+  getErrorPath(error, schemaName) {
+    const details = error.details;
+    if (details && "propertyName" in details && details.propertyName) {
+      return `${schemaName}.${String(details.propertyName)}`;
+    }
+    return schemaName;
+  }
+};
+var validationService = new ValidationService();
+
+// src/server/api/validate.ts
+var validateRouter = Router2();
+validateRouter.post("/", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const body = req.body;
+    let result;
+    if (body.schema) {
+      result = await validationService.validateSchema(body.schema, config.schemasDir);
+    } else if (body.schemas) {
+      result = await validationService.validateAll(body.schemas);
+    } else {
+      result = await validationService.validateFromDisk(config.schemasDir);
+    }
+    const response = {
+      success: true,
+      data: result
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+
+// src/server/api/preview.ts
+import { Router as Router3 } from "express";
+
+// src/server/services/previewService.ts
+import { loadSchemas as loadSchemas3 } from "@famgia/omnify-core";
+import { generateMigrations as generateLaravelMigrations } from "@famgia/omnify-laravel";
+import { generateMigrations as generateSqlMigrations } from "@famgia/omnify-sql";
+var PreviewService = class {
+  async generateAll(schemasDir2, type) {
+    const schemas = await loadSchemas3(schemasDir2);
+    const previews = [];
+    switch (type) {
+      case "laravel": {
+        const migrations = await generateLaravelMigrations(schemas);
+        for (const migration of migrations) {
+          previews.push({
+            type: "laravel",
+            content: migration.content,
+            fileName: migration.fileName
+          });
+        }
+        break;
+      }
+      case "sql": {
+        const migrations = generateSqlMigrations(schemas, { dialect: "mysql" });
+        for (const migration of migrations) {
+          previews.push({
+            type: "sql",
+            content: migration.content,
+            fileName: migration.fileName
+          });
+        }
+        break;
+      }
+      case "typescript": {
+        for (const [name, schema] of Object.entries(schemas)) {
+          if (schema.kind === "enum") {
+            previews.push({
+              type: "typescript",
+              content: this.generateEnumType(name, schema),
+              fileName: `${name}.ts`
+            });
+          } else {
+            previews.push({
+              type: "typescript",
+              content: this.generateInterfaceType(name, schema),
+              fileName: `${name}.ts`
+            });
+          }
+        }
+        break;
+      }
+    }
+    return previews;
+  }
+  async generateForSchema(schemasDir2, schemaName, type) {
+    const schemas = await loadSchemas3(schemasDir2);
+    const schema = schemas[schemaName];
+    if (!schema) {
+      return null;
+    }
+    switch (type) {
+      case "laravel": {
+        const migrations = await generateLaravelMigrations({ [schemaName]: schema });
+        const migration = migrations[0];
+        return migration ? {
+          type: "laravel",
+          content: migration.content,
+          fileName: migration.fileName
+        } : null;
+      }
+      case "sql": {
+        const migrations = generateSqlMigrations({ [schemaName]: schema }, { dialect: "mysql" });
+        const migration = migrations[0];
+        return migration ? {
+          type: "sql",
+          content: migration.content,
+          fileName: migration.fileName
+        } : null;
+      }
+      case "typescript": {
+        if (schema.kind === "enum") {
+          return {
+            type: "typescript",
+            content: this.generateEnumType(schemaName, schema),
+            fileName: `${schemaName}.ts`
+          };
+        }
+        return {
+          type: "typescript",
+          content: this.generateInterfaceType(schemaName, schema),
+          fileName: `${schemaName}.ts`
+        };
+      }
+    }
+  }
+  generateEnumType(name, schema) {
+    const values = schema.values ?? [];
+    return `export type ${name} = ${values.map((v) => `'${v}'`).join(" | ") || "never"};
+`;
+  }
+  generateInterfaceType(name, schema) {
+    const lines = [`export interface ${name} {`];
+    if (schema.properties) {
+      for (const [propName, prop] of Object.entries(schema.properties)) {
+        const tsType = this.mapToTsType(prop.type);
+        const optional = prop.nullable ? "?" : "";
+        lines.push(`  ${propName}${optional}: ${tsType};`);
+      }
+    }
+    lines.push("}");
+    return lines.join("\n") + "\n";
+  }
+  mapToTsType(omnifyType) {
+    const typeMap = {
+      String: "string",
+      Int: "number",
+      BigInt: "number",
+      Float: "number",
+      Decimal: "number",
+      Boolean: "boolean",
+      Text: "string",
+      LongText: "string",
+      Date: "string",
+      Time: "string",
+      Timestamp: "string",
+      Json: "Record<string, unknown>",
+      Email: "string",
+      Password: "string",
+      File: "string",
+      MultiFile: "string[]",
+      Point: "{ lat: number; lng: number }",
+      Coordinates: "{ latitude: number; longitude: number }"
+    };
+    return typeMap[omnifyType] ?? "unknown";
+  }
+};
+var previewService = new PreviewService();
+
+// src/server/api/preview.ts
+var previewRouter = Router3();
+previewRouter.get("/:type", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const { type } = req.params;
+    if (!["laravel", "typescript", "sql"].includes(type)) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "INVALID_TYPE",
+          message: `Invalid preview type: ${type}. Valid types: laravel, typescript, sql`
+        }
+      };
+      res.status(400).json(response2);
+      return;
+    }
+    const previews = await previewService.generateAll(config.schemasDir, type);
+    const response = {
+      success: true,
+      data: previews
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "PREVIEW_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+previewRouter.get("/:type/:name", async (req, res) => {
+  try {
+    const config = req.app.locals.config;
+    const { type, name } = req.params;
+    if (!["laravel", "typescript", "sql"].includes(type)) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "INVALID_TYPE",
+          message: `Invalid preview type: ${type}. Valid types: laravel, typescript, sql`
+        }
+      };
+      res.status(400).json(response2);
+      return;
+    }
+    const preview = await previewService.generateForSchema(
+      config.schemasDir,
+      name,
+      type
+    );
+    if (!preview) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `Schema "${name}" not found`
+        }
+      };
+      res.status(404).json(response2);
+      return;
+    }
+    const response = {
+      success: true,
+      data: preview
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "PREVIEW_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+
+// src/server/api/config.ts
+import { Router as Router4 } from "express";
+
+// src/shared/constants.ts
+var DEFAULT_PORT = 3456;
+var DEFAULT_HOST = "localhost";
+
+// src/server/api/config.ts
+var configRouter = Router4();
+configRouter.get("/", (req, res) => {
+  const appConfig = req.app.locals.config;
+  const config = {
+    schemasDir: appConfig.schemasDir,
+    port: Number(process.env.PORT) || DEFAULT_PORT,
+    host: process.env.HOST ?? DEFAULT_HOST
+  };
+  const response = {
+    success: true,
+    data: config
+  };
+  res.json(response);
+});
+
+// src/server/api/versions.ts
+import { Router as Router5 } from "express";
+
+// src/server/services/versionService.ts
+import { loadSchemas as loadSchemas4 } from "@famgia/omnify-core";
+import {
+  createVersionStore
+} from "@famgia/omnify-core";
+var store = null;
+var schemasDir = null;
+function initVersionStore(baseDir, schemasDirPath) {
+  store = createVersionStore({ baseDir, maxVersions: 100 });
+  schemasDir = schemasDirPath;
+}
+function getStore() {
+  if (!store) {
+    throw new Error("Version store not initialized. Call initVersionStore first.");
+  }
+  return store;
+}
+async function listVersions() {
+  return getStore().listVersions();
+}
+async function getVersion(version) {
+  return getStore().readVersion(version);
+}
+async function getLatestVersion() {
+  return getStore().readLatestVersion();
+}
+async function diffVersions(fromVersion, toVersion) {
+  return getStore().diffVersions(fromVersion, toVersion);
+}
+function propertyToSnapshot(prop) {
+  return {
+    type: prop.type,
+    ...prop.displayName !== void 0 && { displayName: prop.displayName },
+    ...prop.description !== void 0 && { description: prop.description },
+    ...prop.nullable !== void 0 && { nullable: prop.nullable },
+    ...prop.unique !== void 0 && { unique: prop.unique },
+    ...prop.default !== void 0 && { default: prop.default },
+    ...prop.length !== void 0 && { length: prop.length },
+    ...prop.unsigned !== void 0 && { unsigned: prop.unsigned },
+    ...prop.precision !== void 0 && { precision: prop.precision },
+    ...prop.scale !== void 0 && { scale: prop.scale },
+    ...prop.enum !== void 0 && { enum: prop.enum },
+    ...prop.relation !== void 0 && { relation: prop.relation },
+    ...prop.target !== void 0 && { target: prop.target },
+    ...prop.targets !== void 0 && { targets: prop.targets },
+    ...prop.morphName !== void 0 && { morphName: prop.morphName },
+    ...prop.onDelete !== void 0 && { onDelete: prop.onDelete },
+    ...prop.onUpdate !== void 0 && { onUpdate: prop.onUpdate },
+    ...prop.mappedBy !== void 0 && { mappedBy: prop.mappedBy },
+    ...prop.inversedBy !== void 0 && { inversedBy: prop.inversedBy },
+    ...prop.joinTable !== void 0 && { joinTable: prop.joinTable },
+    ...prop.owning !== void 0 && { owning: prop.owning }
+  };
+}
+function schemasToSnapshot(schemas) {
+  const snapshot = {};
+  for (const [name, schema] of Object.entries(schemas)) {
+    const properties = {};
+    if (schema.properties) {
+      for (const [propName, prop] of Object.entries(schema.properties)) {
+        properties[propName] = propertyToSnapshot(prop);
+      }
+    }
+    const opts = schema.options;
+    snapshot[name] = {
+      name: schema.name,
+      kind: schema.kind ?? "object",
+      ...Object.keys(properties).length > 0 && { properties },
+      ...schema.values && { values: schema.values },
+      ...opts && {
+        options: {
+          ...opts.id !== void 0 && { id: opts.id },
+          ...opts.idType !== void 0 && { idType: opts.idType },
+          ...opts.timestamps !== void 0 && { timestamps: opts.timestamps },
+          ...opts.softDelete !== void 0 && { softDelete: opts.softDelete },
+          ...opts.tableName !== void 0 && { tableName: opts.tableName },
+          ...opts.translations !== void 0 && { translations: opts.translations },
+          ...opts.authenticatable !== void 0 && { authenticatable: opts.authenticatable }
+        }
+      }
+    };
+  }
+  return snapshot;
+}
+async function getPendingChanges() {
+  if (!schemasDir) {
+    throw new Error("Schemas directory not initialized");
+  }
+  const storeInstance = getStore();
+  const currentSchemas = await loadSchemas4(schemasDir);
+  const currentSnapshot = schemasToSnapshot(currentSchemas);
+  const latestVersion = await storeInstance.readLatestVersion();
+  if (!latestVersion) {
+    const changes2 = Object.keys(currentSnapshot).map((name) => ({
+      action: "schema_added",
+      schema: name
+    }));
+    return {
+      hasChanges: changes2.length > 0,
+      changes: changes2,
+      currentSchemaCount: Object.keys(currentSnapshot).length,
+      previousSchemaCount: 0,
+      latestVersion: null
+    };
+  }
+  const changes = storeInstance.computeSnapshotDiff(latestVersion.snapshot, currentSnapshot);
+  return {
+    hasChanges: changes.length > 0,
+    changes,
+    currentSchemaCount: Object.keys(currentSnapshot).length,
+    previousSchemaCount: Object.keys(latestVersion.snapshot).length,
+    latestVersion: latestVersion.version
+  };
+}
+
+// src/server/api/versions.ts
+var versionsRouter = Router5();
+versionsRouter.get("/", async (_req, res) => {
+  try {
+    const versions = await listVersions();
+    const response = {
+      success: true,
+      data: versions
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "VERSION_LIST_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+versionsRouter.get("/pending", async (_req, res) => {
+  try {
+    const pending = await getPendingChanges();
+    const response = {
+      success: true,
+      data: pending
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "PENDING_CHANGES_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+versionsRouter.get("/latest", async (_req, res) => {
+  try {
+    const version = await getLatestVersion();
+    const response = {
+      success: true,
+      data: version
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "VERSION_READ_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+versionsRouter.get("/:version", async (req, res) => {
+  try {
+    const versionNum = parseInt(req.params.version, 10);
+    if (isNaN(versionNum)) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "INVALID_VERSION",
+          message: "Version must be a number"
+        }
+      };
+      res.status(400).json(response2);
+      return;
+    }
+    const version = await getVersion(versionNum);
+    if (!version) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "VERSION_NOT_FOUND",
+          message: `Version ${versionNum} not found`
+        }
+      };
+      res.status(404).json(response2);
+      return;
+    }
+    const response = {
+      success: true,
+      data: version
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "VERSION_READ_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+versionsRouter.get("/diff/:from/:to", async (req, res) => {
+  try {
+    const fromVersion = parseInt(req.params.from, 10);
+    const toVersion = parseInt(req.params.to, 10);
+    if (isNaN(fromVersion) || isNaN(toVersion)) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "INVALID_VERSION",
+          message: "Version numbers must be integers"
+        }
+      };
+      res.status(400).json(response2);
+      return;
+    }
+    const diff = await diffVersions(fromVersion, toVersion);
+    if (!diff) {
+      const response2 = {
+        success: false,
+        error: {
+          code: "DIFF_ERROR",
+          message: "Could not compute diff. One or both versions may not exist."
+        }
+      };
+      res.status(404).json(response2);
+      return;
+    }
+    const response = {
+      success: true,
+      data: diff
+    };
+    res.json(response);
+  } catch (error) {
+    const response = {
+      success: false,
+      error: {
+        code: "DIFF_ERROR",
+        message: error.message
+      }
+    };
+    res.status(500).json(response);
+  }
+});
+
+// src/server/app.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function createApp(config) {
+  const app = express();
+  app.locals.config = config;
+  initVersionStore(config.cwd, config.schemasDir);
+  app.use(express.json());
+  app.use("/api/schemas", schemasRouter);
+  app.use("/api/validate", validateRouter);
+  app.use("/api/preview", previewRouter);
+  app.use("/api/config", configRouter);
+  app.use("/api/versions", versionsRouter);
+  if (process.env.NODE_ENV === "production") {
+    const clientDist = join2(__dirname, "../client");
+    app.use(express.static(clientDist));
+    app.get("*", (_req, res) => {
+      res.sendFile(join2(clientDist, "index.html"));
+    });
+  }
+  app.use((err, _req, res, _next) => {
+    console.error("Server error:", err);
+    const response = {
+      success: false,
+      error: {
+        code: "INTERNAL_ERROR",
+        message: err.message
+      }
+    };
+    res.status(500).json(response);
+  });
+  return app;
+}
+
+// src/server/ws/handler.ts
+import { WebSocketServer, WebSocket } from "ws";
+function createWsHandler(server) {
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  const clients = /* @__PURE__ */ new Set();
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    console.log("  WebSocket client connected");
+    const readyEvent = {
+      type: "connection:ready",
+      payload: {
+        schemasDir: process.env.SCHEMAS_DIR ?? "schemas",
+        schemaCount: 0
+      }
+    };
+    ws.send(JSON.stringify(readyEvent));
+    ws.on("message", (data) => {
+      try {
+        const event = JSON.parse(data.toString());
+        handleClientEvent(event, ws);
+      } catch {
+        console.error("Invalid WebSocket message");
+      }
+    });
+    ws.on("close", () => {
+      clients.delete(ws);
+      console.log("  WebSocket client disconnected");
+    });
+    ws.on("error", (error) => {
+      console.error("WebSocket error:", error);
+      clients.delete(ws);
+    });
+  });
+  function handleClientEvent(_event, _ws) {
+  }
+  function broadcast(event) {
+    const message = JSON.stringify(event);
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    }
+  }
+  function close() {
+    for (const client of clients) {
+      client.close();
+    }
+    wss.close();
+  }
+  return { broadcast, close };
+}
+
+// src/server/watcher/fileWatcher.ts
+import chokidar from "chokidar";
+import { basename } from "path";
+function createFileWatcher(schemasDir2, wsHandler) {
+  const watcher = chokidar.watch(`${schemasDir2}/*.yaml`, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 200,
+      pollInterval: 100
+    }
+  });
+  watcher.on("add", (filePath) => {
+    console.log(`  Schema added: ${basename(filePath)}`);
+    void notifySchemaChange(filePath, "file");
+  });
+  watcher.on("change", (filePath) => {
+    console.log(`  Schema changed: ${basename(filePath)}`);
+    void notifySchemaChange(filePath, "file");
+  });
+  watcher.on("unlink", (filePath) => {
+    console.log(`  Schema deleted: ${basename(filePath)}`);
+    void notifyReload();
+  });
+  async function notifySchemaChange(filePath, source) {
+    try {
+      schemaService.clearCache(schemasDir2);
+      const schemas = await schemaService.loadAll(schemasDir2);
+      const name = basename(filePath, ".yaml");
+      const schema = schemas[name];
+      if (schema) {
+        const event = {
+          type: "schema:changed",
+          payload: { name, schema, source }
+        };
+        wsHandler.broadcast(event);
+      }
+    } catch (error) {
+      console.error("Error notifying schema change:", error);
+    }
+  }
+  async function notifyReload() {
+    try {
+      schemaService.clearCache(schemasDir2);
+      const schemas = await schemaService.loadAll(schemasDir2);
+      const event = {
+        type: "schemas:reloaded",
+        payload: { schemas }
+      };
+      wsHandler.broadcast(event);
+    } catch (error) {
+      console.error("Error notifying reload:", error);
+    }
+  }
+  return {
+    close: () => watcher.close()
+  };
+}
+
+// src/server/index.ts
+async function main() {
+  const port = Number(process.env.PORT) || DEFAULT_PORT;
+  const host = process.env.HOST ?? DEFAULT_HOST;
+  const cwd = process.cwd();
+  const schemasDir2 = process.env.SCHEMAS_DIR ?? join3(cwd, "schemas");
+  console.log("Starting Omnify GUI...");
+  console.log(`  Schemas directory: ${schemasDir2}`);
+  const app = createApp({ schemasDir: schemasDir2, cwd });
+  const server = createServer(app);
+  const wsHandler = createWsHandler(server);
+  const watcher = createFileWatcher(schemasDir2, wsHandler);
+  server.listen(port, host, () => {
+    const url = `http://${host}:${port}`;
+    console.log(`  GUI running at: ${url}`);
+    console.log("  Press Ctrl+C to stop\n");
+    if (process.env.NODE_ENV !== "production") {
+      open(url).catch(() => {
+      });
+    }
+  });
+  const shutdown = () => {
+    console.log("\nShutting down...");
+    watcher.close();
+    wsHandler.close();
+    server.close(() => {
+      console.log("Server closed");
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map