@jiggai/kitchen-plugin-marketing 0.2.1

package/dist/api/routes.js

@@ -0,0 +1,1486 @@
+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");
+}