@jiggai/kitchen-plugin-marketing 0.2.10 → 0.2.12

package/dist/api/routes.js

@@ -1,1486 +0,0 @@
-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 __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc6) => {
-  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: !(desc6 = __getOwnPropDesc(from, key)) || desc6.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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/db/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  accountMetrics: () => accountMetrics,
-  accountMetricsRelations: () => accountMetricsRelations,
-  media: () => media,
-  postMetrics: () => postMetrics,
-  postMetricsRelations: () => postMetricsRelations,
-  posts: () => posts,
-  postsRelations: () => postsRelations,
-  socialAccounts: () => socialAccounts,
-  socialAccountsRelations: () => socialAccountsRelations,
-  templates: () => templates,
-  webhooks: () => webhooks
-});
-var import_sqlite_core, import_drizzle_orm, posts, media, templates, socialAccounts, postMetrics, accountMetrics, webhooks, postsRelations, postMetricsRelations, socialAccountsRelations, accountMetricsRelations;
-var init_schema = __esm({
-  "src/db/schema.ts"() {
-    import_sqlite_core = require("drizzle-orm/sqlite-core");
-    import_drizzle_orm = require("drizzle-orm");
-    posts = (0, import_sqlite_core.sqliteTable)("posts", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      teamId: (0, import_sqlite_core.text)("team_id").notNull(),
-      content: (0, import_sqlite_core.text)("content").notNull(),
-      platforms: (0, import_sqlite_core.text)("platforms").notNull(),
-      // JSON array
-      status: (0, import_sqlite_core.text)("status").notNull(),
-      // draft, scheduled, published, failed
-      scheduledAt: (0, import_sqlite_core.text)("scheduled_at"),
-      // ISO string
-      publishedAt: (0, import_sqlite_core.text)("published_at"),
-      // ISO string
-      tags: (0, import_sqlite_core.text)("tags"),
-      // JSON array
-      mediaIds: (0, import_sqlite_core.text)("media_ids"),
-      // JSON array
-      templateId: (0, import_sqlite_core.text)("template_id"),
-      createdAt: (0, import_sqlite_core.text)("created_at").notNull(),
-      updatedAt: (0, import_sqlite_core.text)("updated_at").notNull(),
-      createdBy: (0, import_sqlite_core.text)("created_by").notNull()
-    });
-    media = (0, import_sqlite_core.sqliteTable)("media", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      teamId: (0, import_sqlite_core.text)("team_id").notNull(),
-      filename: (0, import_sqlite_core.text)("filename").notNull(),
-      originalName: (0, import_sqlite_core.text)("original_name").notNull(),
-      mimeType: (0, import_sqlite_core.text)("mime_type").notNull(),
-      size: (0, import_sqlite_core.integer)("size").notNull(),
-      width: (0, import_sqlite_core.integer)("width"),
-      height: (0, import_sqlite_core.integer)("height"),
-      alt: (0, import_sqlite_core.text)("alt"),
-      tags: (0, import_sqlite_core.text)("tags"),
-      // JSON array
-      url: (0, import_sqlite_core.text)("url").notNull(),
-      thumbnailUrl: (0, import_sqlite_core.text)("thumbnail_url"),
-      createdAt: (0, import_sqlite_core.text)("created_at").notNull(),
-      createdBy: (0, import_sqlite_core.text)("created_by").notNull()
-    });
-    templates = (0, import_sqlite_core.sqliteTable)("templates", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      teamId: (0, import_sqlite_core.text)("team_id").notNull(),
-      name: (0, import_sqlite_core.text)("name").notNull(),
-      content: (0, import_sqlite_core.text)("content").notNull(),
-      variables: (0, import_sqlite_core.text)("variables"),
-      // JSON array of variable definitions
-      tags: (0, import_sqlite_core.text)("tags"),
-      // JSON array
-      createdAt: (0, import_sqlite_core.text)("created_at").notNull(),
-      updatedAt: (0, import_sqlite_core.text)("updated_at").notNull(),
-      createdBy: (0, import_sqlite_core.text)("created_by").notNull()
-    });
-    socialAccounts = (0, import_sqlite_core.sqliteTable)("social_accounts", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      teamId: (0, import_sqlite_core.text)("team_id").notNull(),
-      platform: (0, import_sqlite_core.text)("platform").notNull(),
-      // twitter, linkedin, instagram, etc.
-      displayName: (0, import_sqlite_core.text)("display_name").notNull(),
-      username: (0, import_sqlite_core.text)("username"),
-      avatar: (0, import_sqlite_core.text)("avatar"),
-      isActive: (0, import_sqlite_core.integer)("is_active", { mode: "boolean" }).notNull().default(true),
-      credentials: (0, import_sqlite_core.blob)("credentials").notNull(),
-      // Encrypted JSON
-      settings: (0, import_sqlite_core.text)("settings"),
-      // JSON object
-      lastSync: (0, import_sqlite_core.text)("last_sync"),
-      createdAt: (0, import_sqlite_core.text)("created_at").notNull(),
-      updatedAt: (0, import_sqlite_core.text)("updated_at").notNull()
-    });
-    postMetrics = (0, import_sqlite_core.sqliteTable)("post_metrics", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      postId: (0, import_sqlite_core.text)("post_id").notNull(),
-      platform: (0, import_sqlite_core.text)("platform").notNull(),
-      impressions: (0, import_sqlite_core.integer)("impressions").default(0),
-      likes: (0, import_sqlite_core.integer)("likes").default(0),
-      shares: (0, import_sqlite_core.integer)("shares").default(0),
-      comments: (0, import_sqlite_core.integer)("comments").default(0),
-      clicks: (0, import_sqlite_core.integer)("clicks").default(0),
-      engagementRate: (0, import_sqlite_core.text)("engagement_rate"),
-      // Stored as string to avoid float precision issues
-      syncedAt: (0, import_sqlite_core.text)("synced_at").notNull()
-    });
-    accountMetrics = (0, import_sqlite_core.sqliteTable)("account_metrics", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      accountId: (0, import_sqlite_core.text)("account_id").notNull(),
-      date: (0, import_sqlite_core.text)("date").notNull(),
-      // YYYY-MM-DD format
-      followers: (0, import_sqlite_core.integer)("followers").default(0),
-      following: (0, import_sqlite_core.integer)("following").default(0),
-      posts: (0, import_sqlite_core.integer)("posts").default(0),
-      engagement: (0, import_sqlite_core.integer)("engagement").default(0),
-      reach: (0, import_sqlite_core.integer)("reach").default(0),
-      syncedAt: (0, import_sqlite_core.text)("synced_at").notNull()
-    });
-    webhooks = (0, import_sqlite_core.sqliteTable)("webhooks", {
-      id: (0, import_sqlite_core.text)("id").primaryKey(),
-      teamId: (0, import_sqlite_core.text)("team_id").notNull(),
-      url: (0, import_sqlite_core.text)("url").notNull(),
-      events: (0, import_sqlite_core.text)("events").notNull(),
-      // JSON array
-      secret: (0, import_sqlite_core.text)("secret"),
-      isActive: (0, import_sqlite_core.integer)("is_active", { mode: "boolean" }).notNull().default(true),
-      createdAt: (0, import_sqlite_core.text)("created_at").notNull(),
-      lastTriggered: (0, import_sqlite_core.text)("last_triggered")
-    });
-    postsRelations = (0, import_drizzle_orm.relations)(posts, ({ many }) => ({
-      metrics: many(postMetrics)
-    }));
-    postMetricsRelations = (0, import_drizzle_orm.relations)(postMetrics, ({ one }) => ({
-      post: one(posts, {
-        fields: [postMetrics.postId],
-        references: [posts.id]
-      })
-    }));
-    socialAccountsRelations = (0, import_drizzle_orm.relations)(socialAccounts, ({ many }) => ({
-      metrics: many(accountMetrics)
-    }));
-    accountMetricsRelations = (0, import_drizzle_orm.relations)(accountMetrics, ({ one }) => ({
-      account: one(socialAccounts, {
-        fields: [accountMetrics.accountId],
-        references: [socialAccounts.id]
-      })
-    }));
-  }
-});
-
-// src/db/index.ts
-function createDatabase(teamId) {
-  const dbPath = process.env.KITCHEN_PLUGIN_DB_PATH || "./data";
-  const teamDbFile = `${dbPath}/marketing-${teamId}.db`;
-  const sqlite = new import_better_sqlite3.default(teamDbFile);
-  const db = (0, import_better_sqlite32.drizzle)(sqlite, { schema: schema_exports });
-  return { db, sqlite };
-}
-function encryptCredentials(credentials) {
-  const plaintext = JSON.stringify(credentials);
-  const hash = (0, import_crypto.createHash)("sha256").update(ENCRYPTION_KEY).digest();
-  const cipher = (0, import_crypto.createCipher)("aes-256-cbc", hash);
-  let encrypted = cipher.update(plaintext, "utf8", "hex");
-  encrypted += cipher.final("hex");
-  return Buffer.from(encrypted, "hex");
-}
-function initializeDatabase(teamId) {
-  const { db, sqlite } = createDatabase(teamId);
-  try {
-    (0, import_migrator.migrate)(db, { migrationsFolder: "./db/migrations" });
-  } catch (error) {
-    console.warn("Migration warning:", error.message);
-  }
-  return { db, sqlite };
-}
-var import_better_sqlite3, import_better_sqlite32, import_migrator, import_crypto, ENCRYPTION_KEY;
-var init_db = __esm({
-  "src/db/index.ts"() {
-    import_better_sqlite3 = __toESM(require("better-sqlite3"));
-    import_better_sqlite32 = require("drizzle-orm/better-sqlite3");
-    init_schema();
-    import_migrator = require("drizzle-orm/better-sqlite3/migrator");
-    import_crypto = require("crypto");
-    ENCRYPTION_KEY = process.env.KITCHEN_ENCRYPTION_KEY || "fallback-key-change-in-production";
-  }
-});
-
-// src/api/templates.ts
-var templates_exports = {};
-__export(templates_exports, {
-  registerTemplateRoutes: () => registerTemplateRoutes
-});
-function getTeamId(req) {
-  return req.headers["x-team-id"] || req.query.teamId;
-}
-function getUserId(req) {
-  return req.headers["x-user-id"] || "system";
-}
-function sendError(res, status, error, message, details) {
-  const response = { error, message, details };
-  res.status(status).json(response);
-}
-function parsePagination(req) {
-  const limit = Math.min(parseInt(req.query.limit) || 20, 100);
-  const offset = parseInt(req.query.offset) || 0;
-  return { limit, offset };
-}
-function registerTemplateRoutes(app) {
-  app.get("/templates", async (req, res) => {
-    try {
-      const teamId = getTeamId(req);
-      if (!teamId) return sendError(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const { limit, offset } = parsePagination(req);
-      const conditions = [(0, import_drizzle_orm2.eq)(templates.teamId, teamId)];
-      if (req.query.tag) {
-        conditions.push((0, import_drizzle_orm2.like)(templates.tags, `%"${req.query.tag}"%`));
-      }
-      const templates2 = await db.select().from(templates).where((0, import_drizzle_orm2.and)(...conditions)).orderBy((0, import_drizzle_orm2.desc)(templates.createdAt)).limit(limit).offset(offset);
-      const response = templates2.map((template) => ({
-        id: template.id,
-        name: template.name,
-        content: template.content,
-        variables: JSON.parse(template.variables || "[]"),
-        tags: JSON.parse(template.tags || "[]"),
-        createdAt: template.createdAt,
-        updatedAt: template.updatedAt,
-        createdBy: template.createdBy
-      }));
-      res.json({ templates: response });
-    } catch (error) {
-      sendError(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/templates", async (req, res) => {
-    try {
-      const teamId = getTeamId(req);
-      const userId = getUserId(req);
-      if (!teamId) return sendError(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const body = req.body;
-      if (!body.name || !body.content) {
-        return sendError(res, 400, "VALIDATION_ERROR", "Name and content are required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const newTemplate = {
-        id: (0, import_crypto2.randomUUID)(),
-        teamId,
-        name: body.name,
-        content: body.content,
-        variables: JSON.stringify(body.variables || []),
-        tags: JSON.stringify(body.tags || []),
-        createdAt: now,
-        updatedAt: now,
-        createdBy: userId
-      };
-      await db.insert(templates).values(newTemplate);
-      const response = {
-        id: newTemplate.id,
-        name: newTemplate.name,
-        content: newTemplate.content,
-        variables: JSON.parse(newTemplate.variables),
-        tags: JSON.parse(newTemplate.tags),
-        createdAt: newTemplate.createdAt,
-        updatedAt: newTemplate.updatedAt,
-        createdBy: newTemplate.createdBy
-      };
-      res.status(201).json(response);
-    } catch (error) {
-      sendError(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/templates/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId(req);
-      if (!teamId) return sendError(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const template = await db.select().from(templates).where((0, import_drizzle_orm2.and)(
-        (0, import_drizzle_orm2.eq)(templates.id, req.params.id),
-        (0, import_drizzle_orm2.eq)(templates.teamId, teamId)
-      )).get();
-      if (!template) {
-        return sendError(res, 404, "TEMPLATE_NOT_FOUND", "Template not found");
-      }
-      const response = {
-        id: template.id,
-        name: template.name,
-        content: template.content,
-        variables: JSON.parse(template.variables || "[]"),
-        tags: JSON.parse(template.tags || "[]"),
-        createdAt: template.createdAt,
-        updatedAt: template.updatedAt,
-        createdBy: template.createdBy
-      };
-      res.json(response);
-    } catch (error) {
-      sendError(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.put("/templates/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId(req);
-      if (!teamId) return sendError(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const body = req.body;
-      const updateData = {
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (body.name !== void 0) updateData.name = body.name;
-      if (body.content !== void 0) updateData.content = body.content;
-      if (body.variables !== void 0) updateData.variables = JSON.stringify(body.variables);
-      if (body.tags !== void 0) updateData.tags = JSON.stringify(body.tags);
-      const result = await db.update(templates).set(updateData).where((0, import_drizzle_orm2.and)(
-        (0, import_drizzle_orm2.eq)(templates.id, req.params.id),
-        (0, import_drizzle_orm2.eq)(templates.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError(res, 404, "TEMPLATE_NOT_FOUND", "Template not found");
-      }
-      const updatedTemplate = await db.select().from(templates).where((0, import_drizzle_orm2.eq)(templates.id, req.params.id)).get();
-      const response = {
-        id: updatedTemplate.id,
-        name: updatedTemplate.name,
-        content: updatedTemplate.content,
-        variables: JSON.parse(updatedTemplate.variables || "[]"),
-        tags: JSON.parse(updatedTemplate.tags || "[]"),
-        createdAt: updatedTemplate.createdAt,
-        updatedAt: updatedTemplate.updatedAt,
-        createdBy: updatedTemplate.createdBy
-      };
-      res.json(response);
-    } catch (error) {
-      sendError(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.delete("/templates/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId(req);
-      if (!teamId) return sendError(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const result = await db.delete(templates).where((0, import_drizzle_orm2.and)(
-        (0, import_drizzle_orm2.eq)(templates.id, req.params.id),
-        (0, import_drizzle_orm2.eq)(templates.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError(res, 404, "TEMPLATE_NOT_FOUND", "Template not found");
-      }
-      res.status(204).send();
-    } catch (error) {
-      sendError(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-}
-var import_drizzle_orm2, import_crypto2;
-var init_templates = __esm({
-  "src/api/templates.ts"() {
-    import_drizzle_orm2 = require("drizzle-orm");
-    init_db();
-    init_schema();
-    import_crypto2 = require("crypto");
-  }
-});
-
-// src/api/social-accounts.ts
-var social_accounts_exports = {};
-__export(social_accounts_exports, {
-  registerSocialAccountRoutes: () => registerSocialAccountRoutes
-});
-function getTeamId2(req) {
-  return req.headers["x-team-id"] || req.query.teamId;
-}
-function getUserId2(req) {
-  return req.headers["x-user-id"] || "system";
-}
-function sendError2(res, status, error, message, details) {
-  const response = { error, message, details };
-  res.status(status).json(response);
-}
-function registerSocialAccountRoutes(app) {
-  app.get("/accounts", async (req, res) => {
-    try {
-      const teamId = getTeamId2(req);
-      if (!teamId) return sendError2(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const accounts = await db.select().from(socialAccounts).where((0, import_drizzle_orm3.eq)(socialAccounts.teamId, teamId)).orderBy((0, import_drizzle_orm3.desc)(socialAccounts.createdAt));
-      const response = accounts.map((account) => ({
-        id: account.id,
-        platform: account.platform,
-        displayName: account.displayName,
-        username: account.username || void 0,
-        avatar: account.avatar || void 0,
-        isActive: account.isActive,
-        settings: JSON.parse(account.settings || "{}"),
-        lastSync: account.lastSync || void 0,
-        createdAt: account.createdAt,
-        updatedAt: account.updatedAt
-        // Note: credentials are never returned for security
-      }));
-      res.json({ accounts: response });
-    } catch (error) {
-      sendError2(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/accounts", async (req, res) => {
-    try {
-      const teamId = getTeamId2(req);
-      const userId = getUserId2(req);
-      if (!teamId) return sendError2(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const body = req.body;
-      if (!body.platform || !body.displayName || !body.credentials) {
-        return sendError2(res, 400, "VALIDATION_ERROR", "Platform, displayName, and credentials are required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const newAccount = {
-        id: (0, import_crypto3.randomUUID)(),
-        teamId,
-        platform: body.platform,
-        displayName: body.displayName,
-        username: body.username || null,
-        avatar: null,
-        isActive: true,
-        credentials: encryptCredentials(body.credentials),
-        settings: JSON.stringify(body.settings || {}),
-        lastSync: null,
-        createdAt: now,
-        updatedAt: now
-      };
-      await db.insert(socialAccounts).values(newAccount);
-      const response = {
-        id: newAccount.id,
-        platform: newAccount.platform,
-        displayName: newAccount.displayName,
-        username: newAccount.username || void 0,
-        isActive: newAccount.isActive,
-        settings: JSON.parse(newAccount.settings),
-        createdAt: newAccount.createdAt,
-        updatedAt: newAccount.updatedAt
-      };
-      res.status(201).json(response);
-    } catch (error) {
-      sendError2(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/accounts/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId2(req);
-      if (!teamId) return sendError2(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const account = await db.select().from(socialAccounts).where((0, import_drizzle_orm3.and)(
-        (0, import_drizzle_orm3.eq)(socialAccounts.id, req.params.id),
-        (0, import_drizzle_orm3.eq)(socialAccounts.teamId, teamId)
-      )).get();
-      if (!account) {
-        return sendError2(res, 404, "ACCOUNT_NOT_FOUND", "Account not found");
-      }
-      const response = {
-        id: account.id,
-        platform: account.platform,
-        displayName: account.displayName,
-        username: account.username || void 0,
-        avatar: account.avatar || void 0,
-        isActive: account.isActive,
-        settings: JSON.parse(account.settings || "{}"),
-        lastSync: account.lastSync || void 0,
-        createdAt: account.createdAt,
-        updatedAt: account.updatedAt
-      };
-      res.json(response);
-    } catch (error) {
-      sendError2(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.put("/accounts/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId2(req);
-      if (!teamId) return sendError2(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const body = req.body;
-      const updateData = {
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (body.displayName !== void 0) updateData.displayName = body.displayName;
-      if (body.username !== void 0) updateData.username = body.username;
-      if (body.avatar !== void 0) updateData.avatar = body.avatar;
-      if (body.isActive !== void 0) updateData.isActive = body.isActive;
-      if (body.settings !== void 0) updateData.settings = JSON.stringify(body.settings);
-      if (body.credentials !== void 0) updateData.credentials = encryptCredentials(body.credentials);
-      const result = await db.update(socialAccounts).set(updateData).where((0, import_drizzle_orm3.and)(
-        (0, import_drizzle_orm3.eq)(socialAccounts.id, req.params.id),
-        (0, import_drizzle_orm3.eq)(socialAccounts.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError2(res, 404, "ACCOUNT_NOT_FOUND", "Account not found");
-      }
-      res.json({ success: true });
-    } catch (error) {
-      sendError2(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.delete("/accounts/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId2(req);
-      if (!teamId) return sendError2(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const result = await db.delete(socialAccounts).where((0, import_drizzle_orm3.and)(
-        (0, import_drizzle_orm3.eq)(socialAccounts.id, req.params.id),
-        (0, import_drizzle_orm3.eq)(socialAccounts.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError2(res, 404, "ACCOUNT_NOT_FOUND", "Account not found");
-      }
-      await db.delete(accountMetrics).where((0, import_drizzle_orm3.eq)(accountMetrics.accountId, req.params.id));
-      res.status(204).send();
-    } catch (error) {
-      sendError2(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/accounts/:id/metrics", async (req, res) => {
-    try {
-      const teamId = getTeamId2(req);
-      if (!teamId) return sendError2(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const period = req.query.period || "7d";
-      const endDate = /* @__PURE__ */ new Date();
-      const startDate = /* @__PURE__ */ new Date();
-      const days = parseInt(period.replace("d", "")) || 7;
-      startDate.setDate(endDate.getDate() - days);
-      const account = await db.select().from(socialAccounts).where((0, import_drizzle_orm3.and)(
-        (0, import_drizzle_orm3.eq)(socialAccounts.id, req.params.id),
-        (0, import_drizzle_orm3.eq)(socialAccounts.teamId, teamId)
-      )).get();
-      if (!account) {
-        return sendError2(res, 404, "ACCOUNT_NOT_FOUND", "Account not found");
-      }
-      const metrics = await db.select().from(accountMetrics).where((0, import_drizzle_orm3.and)(
-        (0, import_drizzle_orm3.eq)(accountMetrics.accountId, req.params.id)
-        // Add date range filtering here when implemented
-      )).orderBy((0, import_drizzle_orm3.desc)(accountMetrics.date)).limit(parseInt(period.replace("d", "")) || 7);
-      const latestMetric = metrics[0];
-      const oldestMetric = metrics[metrics.length - 1];
-      const followerGrowth = latestMetric && oldestMetric ? (latestMetric.followers || 0) - (oldestMetric.followers || 0) : 0;
-      const totalEngagement = metrics.reduce((sum, m) => sum + (m.engagement || 0), 0);
-      const response = {
-        account: {
-          id: account.id,
-          platform: account.platform,
-          username: account.username
-        },
-        period,
-        metrics: {
-          followerGrowth,
-          totalEngagement,
-          averageEngagement: metrics.length > 0 ? totalEngagement / metrics.length : 0,
-          currentFollowers: latestMetric?.followers || 0,
-          currentFollowing: latestMetric?.following || 0
-        },
-        dailyMetrics: metrics.map((m) => ({
-          date: m.date,
-          followers: m.followers || 0,
-          following: m.following || 0,
-          posts: m.posts || 0,
-          engagement: m.engagement || 0,
-          reach: m.reach || 0
-        }))
-      };
-      res.json(response);
-    } catch (error) {
-      sendError2(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-}
-var import_drizzle_orm3, import_crypto3;
-var init_social_accounts = __esm({
-  "src/api/social-accounts.ts"() {
-    import_drizzle_orm3 = require("drizzle-orm");
-    init_db();
-    init_schema();
-    import_crypto3 = require("crypto");
-  }
-});
-
-// src/api/calendar.ts
-var calendar_exports = {};
-__export(calendar_exports, {
-  registerCalendarRoutes: () => registerCalendarRoutes
-});
-function getTeamId3(req) {
-  return req.headers["x-team-id"] || req.query.teamId;
-}
-function sendError3(res, status, error, message, details) {
-  const response = { error, message, details };
-  res.status(status).json(response);
-}
-function formatDate(date) {
-  return date.toISOString().split("T")[0];
-}
-function registerCalendarRoutes(app) {
-  app.get("/calendar", async (req, res) => {
-    try {
-      const teamId = getTeamId3(req);
-      if (!teamId) return sendError3(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const start = req.query.start;
-      const end = req.query.end;
-      const view = req.query.view || "month";
-      if (!start || !end) {
-        return sendError3(res, 400, "MISSING_DATES", "Start and end dates are required");
-      }
-      const posts2 = await db.select().from(posts).where((0, import_drizzle_orm4.and)(
-        (0, import_drizzle_orm4.eq)(posts.teamId, teamId),
-        (0, import_drizzle_orm4.gte)(posts.scheduledAt, start),
-        (0, import_drizzle_orm4.lte)(posts.scheduledAt, end),
-        (0, import_drizzle_orm4.eq)(posts.status, "scheduled")
-      )).orderBy(posts.scheduledAt);
-      const eventsByDate = {};
-      const platformCounts = {};
-      posts2.forEach((post) => {
-        if (!post.scheduledAt) return;
-        const date = formatDate(new Date(post.scheduledAt));
-        if (!eventsByDate[date]) {
-          eventsByDate[date] = [];
-        }
-        const postResponse = {
-          id: post.id,
-          content: post.content,
-          platforms: JSON.parse(post.platforms || "[]"),
-          status: post.status,
-          scheduledAt: post.scheduledAt,
-          publishedAt: post.publishedAt || void 0,
-          tags: JSON.parse(post.tags || "[]"),
-          mediaIds: JSON.parse(post.mediaIds || "[]"),
-          templateId: post.templateId || void 0,
-          createdAt: post.createdAt,
-          updatedAt: post.updatedAt,
-          createdBy: post.createdBy
-        };
-        eventsByDate[date].push(postResponse);
-        postResponse.platforms.forEach((platform) => {
-          platformCounts[platform] = (platformCounts[platform] || 0) + 1;
-        });
-      });
-      const events = Object.entries(eventsByDate).map(([date, posts3]) => ({
-        date,
-        posts: posts3
-      }));
-      const response = {
-        view,
-        period: `${start} to ${end}`,
-        events,
-        summary: {
-          totalScheduled: posts2.length,
-          byPlatform: platformCounts
-        }
-      };
-      res.json(response);
-    } catch (error) {
-      sendError3(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/calendar/schedule", async (req, res) => {
-    try {
-      const teamId = getTeamId3(req);
-      if (!teamId) return sendError3(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { postId, scheduledAt, platforms } = req.body;
-      if (!postId || !scheduledAt) {
-        return sendError3(res, 400, "VALIDATION_ERROR", "postId and scheduledAt are required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const updateData = {
-        scheduledAt,
-        status: "scheduled",
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (platforms) {
-        updateData.platforms = JSON.stringify(platforms);
-      }
-      const result = await db.update(posts).set(updateData).where((0, import_drizzle_orm4.and)(
-        (0, import_drizzle_orm4.eq)(posts.id, postId),
-        (0, import_drizzle_orm4.eq)(posts.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError3(res, 404, "POST_NOT_FOUND", "Post not found");
-      }
-      res.json({ success: true, scheduledAt });
-    } catch (error) {
-      sendError3(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/calendar/scheduled", async (req, res) => {
-    try {
-      const teamId = getTeamId3(req);
-      if (!teamId) return sendError3(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const posts2 = await db.select().from(posts).where((0, import_drizzle_orm4.and)(
-        (0, import_drizzle_orm4.eq)(posts.teamId, teamId),
-        (0, import_drizzle_orm4.eq)(posts.status, "scheduled")
-      )).orderBy(posts.scheduledAt);
-      const response = posts2.map((post) => ({
-        id: post.id,
-        content: post.content,
-        platforms: JSON.parse(post.platforms || "[]"),
-        status: post.status,
-        scheduledAt: post.scheduledAt || void 0,
-        publishedAt: post.publishedAt || void 0,
-        tags: JSON.parse(post.tags || "[]"),
-        mediaIds: JSON.parse(post.mediaIds || "[]"),
-        templateId: post.templateId || void 0,
-        createdAt: post.createdAt,
-        updatedAt: post.updatedAt,
-        createdBy: post.createdBy
-      }));
-      res.json({ scheduled: response });
-    } catch (error) {
-      sendError3(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.put("/calendar/scheduled/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId3(req);
-      if (!teamId) return sendError3(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { scheduledAt, platforms } = req.body;
-      if (!scheduledAt) {
-        return sendError3(res, 400, "VALIDATION_ERROR", "scheduledAt is required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const updateData = {
-        scheduledAt,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (platforms) {
-        updateData.platforms = JSON.stringify(platforms);
-      }
-      const result = await db.update(posts).set(updateData).where((0, import_drizzle_orm4.and)(
-        (0, import_drizzle_orm4.eq)(posts.id, req.params.id),
-        (0, import_drizzle_orm4.eq)(posts.teamId, teamId),
-        (0, import_drizzle_orm4.eq)(posts.status, "scheduled")
-      ));
-      if (result.changes === 0) {
-        return sendError3(res, 404, "SCHEDULED_POST_NOT_FOUND", "Scheduled post not found");
-      }
-      res.json({ success: true, scheduledAt });
-    } catch (error) {
-      sendError3(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/calendar/bulk-schedule", async (req, res) => {
-    try {
-      const teamId = getTeamId3(req);
-      const userId = req.headers["x-user-id"] || "system";
-      if (!teamId) return sendError3(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { posts: posts2 } = req.body;
-      if (!Array.isArray(posts2) || posts2.length === 0) {
-        return sendError3(res, 400, "VALIDATION_ERROR", "Posts array is required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const createdPosts = [];
-      for (const postData of posts2) {
-        if (!postData.content || !postData.scheduledAt || !postData.platforms?.length) {
-          continue;
-        }
-        const newPost = {
-          id: require("crypto").randomUUID(),
-          teamId,
-          content: postData.content,
-          platforms: JSON.stringify(postData.platforms),
-          status: "scheduled",
-          scheduledAt: postData.scheduledAt,
-          publishedAt: null,
-          tags: JSON.stringify(postData.tags || []),
-          mediaIds: JSON.stringify(postData.mediaIds || []),
-          templateId: postData.templateId || null,
-          createdAt: now,
-          updatedAt: now,
-          createdBy: userId
-        };
-        await db.insert(posts).values(newPost);
-        createdPosts.push({
-          id: newPost.id,
-          content: newPost.content,
-          platforms: JSON.parse(newPost.platforms),
-          status: newPost.status,
-          scheduledAt: newPost.scheduledAt || void 0,
-          tags: JSON.parse(newPost.tags),
-          mediaIds: JSON.parse(newPost.mediaIds),
-          templateId: newPost.templateId || void 0,
-          createdAt: newPost.createdAt,
-          updatedAt: newPost.updatedAt,
-          createdBy: newPost.createdBy
-        });
-      }
-      res.status(201).json({
-        success: true,
-        created: createdPosts.length,
-        posts: createdPosts
-      });
-    } catch (error) {
-      sendError3(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-}
-var import_drizzle_orm4;
-var init_calendar = __esm({
-  "src/api/calendar.ts"() {
-    import_drizzle_orm4 = require("drizzle-orm");
-    init_db();
-    init_schema();
-  }
-});
-
-// src/api/webhooks.ts
-var webhooks_exports = {};
-__export(webhooks_exports, {
-  registerWebhookRoutes: () => registerWebhookRoutes
-});
-function getTeamId4(req) {
-  return req.headers["x-team-id"] || req.query.teamId;
-}
-function sendError4(res, status, error, message, details) {
-  const response = { error, message, details };
-  res.status(status).json(response);
-}
-function registerWebhookRoutes(app) {
-  app.get("/webhooks", async (req, res) => {
-    try {
-      const teamId = getTeamId4(req);
-      if (!teamId) return sendError4(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const webhooks2 = await db.select().from(webhooks).where((0, import_drizzle_orm5.eq)(webhooks.teamId, teamId)).orderBy((0, import_drizzle_orm5.desc)(webhooks.createdAt));
-      const response = webhooks2.map((webhook) => ({
-        id: webhook.id,
-        url: webhook.url,
-        events: JSON.parse(webhook.events || "[]"),
-        isActive: webhook.isActive,
-        createdAt: webhook.createdAt,
-        lastTriggered: webhook.lastTriggered || void 0
-      }));
-      res.json({ webhooks: response });
-    } catch (error) {
-      sendError4(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/webhooks", async (req, res) => {
-    try {
-      const teamId = getTeamId4(req);
-      if (!teamId) return sendError4(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const body = req.body;
-      if (!body.url || !body.events?.length) {
-        return sendError4(res, 400, "VALIDATION_ERROR", "URL and events are required");
-      }
-      try {
-        new URL(body.url);
-      } catch {
-        return sendError4(res, 400, "INVALID_URL", "Invalid webhook URL");
-      }
-      const { db } = initializeDatabase(teamId);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const newWebhook = {
-        id: (0, import_crypto4.randomUUID)(),
-        teamId,
-        url: body.url,
-        events: JSON.stringify(body.events),
-        secret: body.secret || null,
-        isActive: true,
-        createdAt: now,
-        lastTriggered: null
-      };
-      await db.insert(webhooks).values(newWebhook);
-      const response = {
-        id: newWebhook.id,
-        url: newWebhook.url,
-        events: JSON.parse(newWebhook.events),
-        isActive: newWebhook.isActive,
-        createdAt: newWebhook.createdAt
-      };
-      res.status(201).json(response);
-    } catch (error) {
-      sendError4(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/webhooks/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId4(req);
-      if (!teamId) return sendError4(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const webhook = await db.select().from(webhooks).where((0, import_drizzle_orm5.and)(
-        (0, import_drizzle_orm5.eq)(webhooks.id, req.params.id),
-        (0, import_drizzle_orm5.eq)(webhooks.teamId, teamId)
-      )).get();
-      if (!webhook) {
-        return sendError4(res, 404, "WEBHOOK_NOT_FOUND", "Webhook not found");
-      }
-      const response = {
-        id: webhook.id,
-        url: webhook.url,
-        events: JSON.parse(webhook.events || "[]"),
-        isActive: webhook.isActive,
-        createdAt: webhook.createdAt,
-        lastTriggered: webhook.lastTriggered || void 0
-      };
-      res.json(response);
-    } catch (error) {
-      sendError4(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.put("/webhooks/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId4(req);
-      if (!teamId) return sendError4(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const body = req.body;
-      const updateData = {};
-      if (body.url !== void 0) {
-        try {
-          new URL(body.url);
-          updateData.url = body.url;
-        } catch {
-          return sendError4(res, 400, "INVALID_URL", "Invalid webhook URL");
-        }
-      }
-      if (body.events !== void 0) updateData.events = JSON.stringify(body.events);
-      if (body.secret !== void 0) updateData.secret = body.secret;
-      if (body.isActive !== void 0) updateData.isActive = body.isActive;
-      const result = await db.update(webhooks).set(updateData).where((0, import_drizzle_orm5.and)(
-        (0, import_drizzle_orm5.eq)(webhooks.id, req.params.id),
-        (0, import_drizzle_orm5.eq)(webhooks.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError4(res, 404, "WEBHOOK_NOT_FOUND", "Webhook not found");
-      }
-      res.json({ success: true });
-    } catch (error) {
-      sendError4(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.delete("/webhooks/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId4(req);
-      if (!teamId) return sendError4(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const result = await db.delete(webhooks).where((0, import_drizzle_orm5.and)(
-        (0, import_drizzle_orm5.eq)(webhooks.id, req.params.id),
-        (0, import_drizzle_orm5.eq)(webhooks.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError4(res, 404, "WEBHOOK_NOT_FOUND", "Webhook not found");
-      }
-      res.status(204).send();
-    } catch (error) {
-      sendError4(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/webhooks/test", async (req, res) => {
-    try {
-      const teamId = getTeamId4(req);
-      if (!teamId) return sendError4(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { webhookId, event, data } = req.body;
-      if (!webhookId || !event) {
-        return sendError4(res, 400, "VALIDATION_ERROR", "webhookId and event are required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const webhook = await db.select().from(webhooks).where((0, import_drizzle_orm5.and)(
-        (0, import_drizzle_orm5.eq)(webhooks.id, webhookId),
-        (0, import_drizzle_orm5.eq)(webhooks.teamId, teamId),
-        (0, import_drizzle_orm5.eq)(webhooks.isActive, true)
-      )).get();
-      if (!webhook) {
-        return sendError4(res, 404, "WEBHOOK_NOT_FOUND", "Active webhook not found");
-      }
-      const events = JSON.parse(webhook.events || "[]");
-      if (!events.includes(event)) {
-        return sendError4(res, 400, "EVENT_NOT_SUBSCRIBED", "Webhook not subscribed to this event");
-      }
-      const payload = {
-        event,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        teamId,
-        data: data || { test: true }
-      };
-      try {
-        const response = await fetch(webhook.url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "User-Agent": "KitchenPlugin-Marketing/1.0",
-            ...webhook.secret && {
-              "X-Webhook-Signature": require("crypto").createHmac("sha256", webhook.secret).update(JSON.stringify(payload)).digest("hex")
-            }
-          },
-          body: JSON.stringify(payload),
-          signal: AbortSignal.timeout(1e4)
-        });
-        const responseText = await response.text();
-        await db.update(webhooks).set({ lastTriggered: (/* @__PURE__ */ new Date()).toISOString() }).where((0, import_drizzle_orm5.eq)(webhooks.id, webhookId));
-        res.json({
-          success: response.ok,
-          status: response.status,
-          response: responseText,
-          url: webhook.url
-        });
-      } catch (error) {
-        res.json({
-          success: false,
-          error: error.message,
-          url: webhook.url
-        });
-      }
-    } catch (error) {
-      sendError4(res, 500, "WEBHOOK_TEST_ERROR", error.message);
-    }
-  });
-}
-var import_drizzle_orm5, import_crypto4;
-var init_webhooks = __esm({
-  "src/api/webhooks.ts"() {
-    import_drizzle_orm5 = require("drizzle-orm");
-    init_db();
-    init_schema();
-    import_crypto4 = require("crypto");
-  }
-});
-
-// src/api/routes.ts
-var routes_exports = {};
-__export(routes_exports, {
-  default: () => createRoutes
-});
-module.exports = __toCommonJS(routes_exports);
-var import_drizzle_orm6 = require("drizzle-orm");
-init_db();
-init_schema();
-var import_crypto5 = require("crypto");
-var import_multer = __toESM(require("multer"));
-var import_path = __toESM(require("path"));
-var import_promises = __toESM(require("fs/promises"));
-var upload = (0, import_multer.default)({
-  dest: "uploads/",
-  limits: {
-    fileSize: 10 * 1024 * 1024
-    // 10MB limit
-  },
-  fileFilter: (req, file, cb) => {
-    const allowedTypes = ["image/jpeg", "image/png", "image/gif", "image/webp", "video/mp4"];
-    if (allowedTypes.includes(file.mimetype)) {
-      cb(null, true);
-    } else {
-      cb(new Error("Invalid file type"));
-    }
-  }
-});
-function getTeamId5(req) {
-  return req.headers["x-team-id"] || req.query.teamId;
-}
-function getUserId3(req) {
-  return req.headers["x-user-id"] || "system";
-}
-function sendError5(res, status, error, message, details) {
-  const response = { error, message, details };
-  res.status(status).json(response);
-}
-function parsePagination2(req) {
-  const limit = Math.min(parseInt(req.query.limit) || 20, 100);
-  const offset = parseInt(req.query.offset) || 0;
-  return { limit, offset };
-}
-function createRoutes(app) {
-  app.get("/posts", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const { limit, offset } = parsePagination2(req);
-      const conditions = [(0, import_drizzle_orm6.eq)(posts.teamId, teamId)];
-      if (req.query.status) {
-        conditions.push((0, import_drizzle_orm6.eq)(posts.status, req.query.status));
-      }
-      if (req.query.platform) {
-        conditions.push((0, import_drizzle_orm6.like)(posts.platforms, `%"${req.query.platform}"%`));
-      }
-      if (req.query.tag) {
-        conditions.push((0, import_drizzle_orm6.like)(posts.tags, `%"${req.query.tag}"%`));
-      }
-      const totalResult = await db.select({ count: import_drizzle_orm6.sql`count(*)` }).from(posts).where((0, import_drizzle_orm6.and)(...conditions));
-      const total = totalResult[0].count;
-      const posts2 = await db.select().from(posts).where((0, import_drizzle_orm6.and)(...conditions)).orderBy((0, import_drizzle_orm6.desc)(posts.createdAt)).limit(limit).offset(offset);
-      const transformedPosts = posts2.map((post) => ({
-        id: post.id,
-        content: post.content,
-        platforms: JSON.parse(post.platforms || "[]"),
-        status: post.status,
-        scheduledAt: post.scheduledAt || void 0,
-        publishedAt: post.publishedAt || void 0,
-        tags: JSON.parse(post.tags || "[]"),
-        mediaIds: JSON.parse(post.mediaIds || "[]"),
-        templateId: post.templateId || void 0,
-        createdAt: post.createdAt,
-        updatedAt: post.updatedAt,
-        createdBy: post.createdBy
-      }));
-      const response = {
-        data: transformedPosts,
-        total,
-        offset,
-        limit,
-        hasMore: offset + limit < total
-      };
-      res.json(response);
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/posts", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      const userId = getUserId3(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const body = req.body;
-      if (!body.content || !body.platforms?.length) {
-        return sendError5(res, 400, "VALIDATION_ERROR", "Content and platforms are required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const newPost = {
-        id: (0, import_crypto5.randomUUID)(),
-        teamId,
-        content: body.content,
-        platforms: JSON.stringify(body.platforms),
-        status: body.status || "draft",
-        scheduledAt: body.scheduledAt || null,
-        publishedAt: null,
-        tags: JSON.stringify(body.tags || []),
-        mediaIds: JSON.stringify(body.mediaIds || []),
-        templateId: body.templateId || null,
-        createdAt: now,
-        updatedAt: now,
-        createdBy: userId
-      };
-      await db.insert(posts).values(newPost);
-      const response = {
-        id: newPost.id,
-        content: newPost.content,
-        platforms: JSON.parse(newPost.platforms),
-        status: newPost.status,
-        scheduledAt: newPost.scheduledAt || void 0,
-        publishedAt: void 0,
-        tags: JSON.parse(newPost.tags),
-        mediaIds: JSON.parse(newPost.mediaIds),
-        templateId: newPost.templateId || void 0,
-        createdAt: newPost.createdAt,
-        updatedAt: newPost.updatedAt,
-        createdBy: newPost.createdBy
-      };
-      res.status(201).json(response);
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/posts/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const post = await db.select().from(posts).where((0, import_drizzle_orm6.and)(
-        (0, import_drizzle_orm6.eq)(posts.id, req.params.id),
-        (0, import_drizzle_orm6.eq)(posts.teamId, teamId)
-      )).get();
-      if (!post) {
-        return sendError5(res, 404, "POST_NOT_FOUND", "Post not found");
-      }
-      const metrics = await db.select().from(postMetrics).where((0, import_drizzle_orm6.eq)(postMetrics.postId, post.id));
-      const platformMetrics = {};
-      metrics.forEach((metric) => {
-        platformMetrics[metric.platform] = {
-          impressions: metric.impressions || 0,
-          likes: metric.likes || 0,
-          shares: metric.shares || 0,
-          comments: metric.comments || 0,
-          clicks: metric.clicks || 0,
-          engagementRate: parseFloat(metric.engagementRate || "0")
-        };
-      });
-      const response = {
-        id: post.id,
-        content: post.content,
-        platforms: JSON.parse(post.platforms || "[]"),
-        status: post.status,
-        scheduledAt: post.scheduledAt || void 0,
-        publishedAt: post.publishedAt || void 0,
-        tags: JSON.parse(post.tags || "[]"),
-        mediaIds: JSON.parse(post.mediaIds || "[]"),
-        templateId: post.templateId || void 0,
-        createdAt: post.createdAt,
-        updatedAt: post.updatedAt,
-        createdBy: post.createdBy,
-        metrics: Object.keys(platformMetrics).length > 0 ? platformMetrics : void 0
-      };
-      res.json(response);
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.put("/posts/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const body = req.body;
-      const updateData = {
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (body.content !== void 0) updateData.content = body.content;
-      if (body.platforms !== void 0) updateData.platforms = JSON.stringify(body.platforms);
-      if (body.status !== void 0) updateData.status = body.status;
-      if (body.scheduledAt !== void 0) updateData.scheduledAt = body.scheduledAt;
-      if (body.tags !== void 0) updateData.tags = JSON.stringify(body.tags);
-      if (body.mediaIds !== void 0) updateData.mediaIds = JSON.stringify(body.mediaIds);
-      const result = await db.update(posts).set(updateData).where((0, import_drizzle_orm6.and)(
-        (0, import_drizzle_orm6.eq)(posts.id, req.params.id),
-        (0, import_drizzle_orm6.eq)(posts.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError5(res, 404, "POST_NOT_FOUND", "Post not found");
-      }
-      const updatedPost = await db.select().from(posts).where((0, import_drizzle_orm6.eq)(posts.id, req.params.id)).get();
-      const response = {
-        id: updatedPost.id,
-        content: updatedPost.content,
-        platforms: JSON.parse(updatedPost.platforms || "[]"),
-        status: updatedPost.status,
-        scheduledAt: updatedPost.scheduledAt || void 0,
-        publishedAt: updatedPost.publishedAt || void 0,
-        tags: JSON.parse(updatedPost.tags || "[]"),
-        mediaIds: JSON.parse(updatedPost.mediaIds || "[]"),
-        templateId: updatedPost.templateId || void 0,
-        createdAt: updatedPost.createdAt,
-        updatedAt: updatedPost.updatedAt,
-        createdBy: updatedPost.createdBy
-      };
-      res.json(response);
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.delete("/posts/:id", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const result = await db.delete(posts).where((0, import_drizzle_orm6.and)(
-        (0, import_drizzle_orm6.eq)(posts.id, req.params.id),
-        (0, import_drizzle_orm6.eq)(posts.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError5(res, 404, "POST_NOT_FOUND", "Post not found");
-      }
-      await db.delete(postMetrics).where((0, import_drizzle_orm6.eq)(postMetrics.postId, req.params.id));
-      res.status(204).send();
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/posts/:id/publish", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const { platforms } = req.body;
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const updateData = {
-        status: "published",
-        publishedAt: now,
-        updatedAt: now
-      };
-      if (platforms) {
-        updateData.platforms = JSON.stringify(platforms);
-      }
-      const result = await db.update(posts).set(updateData).where((0, import_drizzle_orm6.and)(
-        (0, import_drizzle_orm6.eq)(posts.id, req.params.id),
-        (0, import_drizzle_orm6.eq)(posts.teamId, teamId)
-      ));
-      if (result.changes === 0) {
-        return sendError5(res, 404, "POST_NOT_FOUND", "Post not found");
-      }
-      res.json({ success: true, publishedAt: now });
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.get("/media", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const { limit, offset } = parsePagination2(req);
-      const conditions = [(0, import_drizzle_orm6.eq)(media.teamId, teamId)];
-      if (req.query.tag) {
-        conditions.push((0, import_drizzle_orm6.like)(media.tags, `%"${req.query.tag}"%`));
-      }
-      if (req.query.type) {
-        conditions.push((0, import_drizzle_orm6.like)(media.mimeType, `${req.query.type}%`));
-      }
-      const media2 = await db.select().from(media).where((0, import_drizzle_orm6.and)(...conditions)).orderBy((0, import_drizzle_orm6.desc)(media.createdAt)).limit(limit).offset(offset);
-      const response = media2.map((item) => ({
-        id: item.id,
-        filename: item.filename,
-        originalName: item.originalName,
-        mimeType: item.mimeType,
-        size: item.size,
-        width: item.width || void 0,
-        height: item.height || void 0,
-        alt: item.alt || void 0,
-        tags: JSON.parse(item.tags || "[]"),
-        url: item.url,
-        thumbnailUrl: item.thumbnailUrl || void 0,
-        createdAt: item.createdAt,
-        createdBy: item.createdBy
-      }));
-      res.json({ media: response });
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  app.post("/media", upload.single("file"), async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      const userId = getUserId3(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      if (!req.file) {
-        return sendError5(res, 400, "NO_FILE", "File is required");
-      }
-      const { db } = initializeDatabase(teamId);
-      const body = req.body;
-      const mediaId = (0, import_crypto5.randomUUID)();
-      const filename = `${mediaId}${import_path.default.extname(req.file.originalname)}`;
-      const mediaDir = `./uploads/media/${teamId}`;
-      await import_promises.default.mkdir(mediaDir, { recursive: true });
-      const finalPath = import_path.default.join(mediaDir, filename);
-      await import_promises.default.rename(req.file.path, finalPath);
-      const newMedia = {
-        id: mediaId,
-        teamId,
-        filename,
-        originalName: req.file.originalname,
-        mimeType: req.file.mimetype,
-        size: req.file.size,
-        width: null,
-        // TODO: Extract dimensions for images
-        height: null,
-        alt: body.alt || null,
-        tags: JSON.stringify(body.tags || []),
-        url: `/api/plugins/kitchen-plugin-marketing/media/${mediaId}/file`,
-        thumbnailUrl: null,
-        // TODO: Generate thumbnails
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        createdBy: userId
-      };
-      await db.insert(media).values(newMedia);
-      const response = {
-        id: newMedia.id,
-        filename: newMedia.filename,
-        originalName: newMedia.originalName,
-        mimeType: newMedia.mimeType,
-        size: newMedia.size,
-        alt: newMedia.alt || void 0,
-        tags: JSON.parse(newMedia.tags),
-        url: newMedia.url,
-        createdAt: newMedia.createdAt,
-        createdBy: newMedia.createdBy
-      };
-      res.status(201).json(response);
-    } catch (error) {
-      sendError5(res, 500, "UPLOAD_ERROR", error.message);
-    }
-  });
-  app.get("/media/:id/file", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const media2 = await db.select().from(media).where((0, import_drizzle_orm6.and)(
-        (0, import_drizzle_orm6.eq)(media.id, req.params.id),
-        (0, import_drizzle_orm6.eq)(media.teamId, teamId)
-      )).get();
-      if (!media2) {
-        return sendError5(res, 404, "MEDIA_NOT_FOUND", "Media not found");
-      }
-      const filePath = `./uploads/media/${teamId}/${media2.filename}`;
-      res.set("Content-Type", media2.mimeType);
-      res.sendFile(import_path.default.resolve(filePath));
-    } catch (error) {
-      sendError5(res, 500, "FILE_ERROR", error.message);
-    }
-  });
-  app.get("/analytics/overview", async (req, res) => {
-    try {
-      const teamId = getTeamId5(req);
-      if (!teamId) return sendError5(res, 400, "MISSING_TEAM_ID", "Team ID is required");
-      const { db } = initializeDatabase(teamId);
-      const period = req.query.period || "30d";
-      const endDate = /* @__PURE__ */ new Date();
-      const startDate = /* @__PURE__ */ new Date();
-      const days = parseInt(period.replace("d", "")) || 30;
-      startDate.setDate(endDate.getDate() - days);
-      const metrics = await db.select({
-        platform: postMetrics.platform,
-        totalImpressions: import_drizzle_orm6.sql`sum(${postMetrics.impressions})`,
-        totalLikes: import_drizzle_orm6.sql`sum(${postMetrics.likes})`,
-        totalShares: import_drizzle_orm6.sql`sum(${postMetrics.shares})`,
-        totalComments: import_drizzle_orm6.sql`sum(${postMetrics.comments})`,
-        totalClicks: import_drizzle_orm6.sql`sum(${postMetrics.clicks})`,
-        postCount: import_drizzle_orm6.sql`count(distinct ${postMetrics.postId})`
-      }).from(postMetrics).innerJoin(posts, (0, import_drizzle_orm6.eq)(posts.id, postMetrics.postId)).where((0, import_drizzle_orm6.and)(
-        (0, import_drizzle_orm6.eq)(posts.teamId, teamId),
-        (0, import_drizzle_orm6.gte)(posts.publishedAt, startDate.toISOString())
-      )).groupBy(postMetrics.platform);
-      let totalPosts = 0;
-      let totalImpressions = 0;
-      let totalEngagements = 0;
-      let totalClicks = 0;
-      const platformBreakdown = {};
-      metrics.forEach((metric) => {
-        const engagements = (metric.totalLikes || 0) + (metric.totalShares || 0) + (metric.totalComments || 0);
-        totalPosts += metric.postCount || 0;
-        totalImpressions += metric.totalImpressions || 0;
-        totalEngagements += engagements;
-        totalClicks += metric.totalClicks || 0;
-        platformBreakdown[metric.platform] = {
-          posts: metric.postCount || 0,
-          impressions: metric.totalImpressions || 0,
-          engagements
-        };
-      });
-      const response = {
-        period,
-        metrics: {
-          totalPosts,
-          totalImpressions,
-          totalEngagements,
-          totalClicks,
-          engagementRate: totalImpressions > 0 ? totalEngagements / totalImpressions * 100 : 0,
-          averageImpressions: totalPosts > 0 ? totalImpressions / totalPosts : 0
-        },
-        platformBreakdown
-      };
-      res.json(response);
-    } catch (error) {
-      sendError5(res, 500, "DATABASE_ERROR", error.message);
-    }
-  });
-  const { registerTemplateRoutes: registerTemplateRoutes2 } = (init_templates(), __toCommonJS(templates_exports));
-  const { registerSocialAccountRoutes: registerSocialAccountRoutes2 } = (init_social_accounts(), __toCommonJS(social_accounts_exports));
-  const { registerCalendarRoutes: registerCalendarRoutes2 } = (init_calendar(), __toCommonJS(calendar_exports));
-  const { registerWebhookRoutes: registerWebhookRoutes2 } = (init_webhooks(), __toCommonJS(webhooks_exports));
-  registerTemplateRoutes2(app);
-  registerSocialAccountRoutes2(app);
-  registerCalendarRoutes2(app);
-  registerWebhookRoutes2(app);
-  console.log("Marketing plugin API routes registered");
-}