@jiggai/kitchen-plugin-marketing 0.2.8 → 0.2.10

package/dist/api/handler.js

@@ -198,6 +198,13 @@ function encryptCredentials(credentials) {
   encrypted += cipher.final("hex");
   return Buffer.from(encrypted, "hex");
 }
+function decryptCredentials(encryptedData) {
+  const hash = (0, import_crypto.createHash)("sha256").update(ENCRYPTION_KEY).digest();
+  const decipher = (0, import_crypto.createDecipher)("aes-256-cbc", hash);
+  let decrypted = decipher.update(encryptedData.toString("hex"), "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return JSON.parse(decrypted);
+}
 function initializeDatabase(teamId) {
   const { db, sqlite } = createDatabase(teamId);
   try {
@@ -208,6 +215,311 @@ function initializeDatabase(teamId) {
   return { db, sqlite };
 }
 
+// src/drivers/postiz-backend.ts
+async function postizFetch(config, path, options) {
+  return fetch(`${config.baseUrl}${path}`, {
+    ...options,
+    headers: {
+      "Authorization": config.apiKey,
+      "Content-Type": "application/json",
+      ...options?.headers || {}
+    }
+  });
+}
+async function getPostizIntegrations(config) {
+  const res = await postizFetch(config, "/integrations");
+  if (!res.ok) return [];
+  const data = await res.json();
+  return Array.isArray(data) ? data : data.integrations || [];
+}
+async function postizPublish(config, integrationId, content, options) {
+  const payload = {
+    content,
+    integrationIds: [integrationId]
+  };
+  if (options?.scheduledAt) payload.date = options.scheduledAt;
+  if (options?.settings) payload.settings = options.settings;
+  if (options?.mediaUrls?.length) {
+    payload.media = options.mediaUrls.map((url) => ({ url }));
+  }
+  const res = await postizFetch(config, "/posts", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  const data = await res.json().catch(() => null);
+  if (!res.ok) {
+    return { success: false, error: data?.message || `Postiz error ${res.status}`, meta: data };
+  }
+  return { success: true, postId: data?.id, meta: data };
+}
+
+// src/drivers/base-driver.ts
+var BaseDriver = class {
+  config;
+  _postizIntegrationId = null;
+  _statusCache = null;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Platform-specific character limit */
+  getMaxLength() {
+    return void 0;
+  }
+  /** Platform-specific supported media types */
+  getSupportedMedia() {
+    return void 0;
+  }
+  getCapabilities() {
+    const hasPostiz = !!this.config.postiz;
+    const hasGateway = !!this.config.gateway;
+    const hasDirect = !!this.config.direct;
+    return {
+      canPost: hasPostiz || hasGateway || hasDirect,
+      canSchedule: hasPostiz,
+      // only Postiz supports native scheduling
+      canDelete: false,
+      canUploadMedia: hasPostiz || hasDirect,
+      maxLength: this.getMaxLength(),
+      supportedMedia: this.getSupportedMedia()
+    };
+  }
+  async getStatus() {
+    if (this._statusCache) return this._statusCache;
+    if (this.config.postiz) {
+      try {
+        const integrations = await getPostizIntegrations(this.config.postiz);
+        const match = integrations.find(
+          (i) => i.providerIdentifier === this.postizProvider && !i.disabled
+        );
+        if (match) {
+          this._postizIntegrationId = this.config.postiz.integrationId || match.id;
+          this._statusCache = {
+            connected: true,
+            backend: "postiz",
+            displayName: match.name || `${this.label} (Postiz)`,
+            username: match.username,
+            avatar: match.picture,
+            integrationId: match.id
+          };
+          return this._statusCache;
+        }
+      } catch {
+      }
+    }
+    if (this.config.gateway) {
+      this._statusCache = {
+        connected: true,
+        backend: "gateway",
+        displayName: `${this.label} (via OpenClaw)`
+      };
+      return this._statusCache;
+    }
+    if (this.config.direct?.accessToken) {
+      this._statusCache = {
+        connected: true,
+        backend: "direct",
+        displayName: `${this.label} (Direct API)`
+      };
+      return this._statusCache;
+    }
+    this._statusCache = {
+      connected: false,
+      backend: "none",
+      displayName: this.label
+    };
+    return this._statusCache;
+  }
+  async publish(content) {
+    const status = await this.getStatus();
+    switch (status.backend) {
+      case "postiz":
+        return this.publishViaPostiz(content);
+      case "gateway":
+        return this.publishViaGateway(content);
+      case "direct":
+        return this.publishDirect(content);
+      default:
+        return { success: false, error: `No backend configured for ${this.label}` };
+    }
+  }
+  /** Publish through Postiz */
+  async publishViaPostiz(content) {
+    const cfg = this.config.postiz;
+    if (!cfg) return { success: false, error: "Postiz not configured" };
+    const integrationId = this._postizIntegrationId || cfg.integrationId;
+    if (!integrationId) return { success: false, error: "No Postiz integration found for " + this.platform };
+    const result = await postizPublish(cfg, integrationId, content.text, {
+      scheduledAt: content.scheduledAt,
+      mediaUrls: content.mediaUrls,
+      settings: content.settings
+    });
+    return {
+      success: result.success,
+      postId: result.postId,
+      error: result.error,
+      scheduledAt: content.scheduledAt,
+      meta: result.meta
+    };
+  }
+  /** Publish through OpenClaw gateway messaging. Override for platform-specific formatting. */
+  async publishViaGateway(_content) {
+    return { success: false, error: `Gateway publishing not implemented for ${this.label}` };
+  }
+  /** Direct API publish. Override per platform. */
+  async publishDirect(_content) {
+    return { success: false, error: `Direct API publishing not implemented for ${this.label}` };
+  }
+};
+
+// src/drivers/x-driver.ts
+var XDriver = class extends BaseDriver {
+  platform = "x";
+  label = "X (Twitter)";
+  icon = "\u{1D54F}";
+  postizProvider = "x";
+  getMaxLength() {
+    return 280;
+  }
+  getSupportedMedia() {
+    return ["image/jpeg", "image/png", "image/gif", "video/mp4"];
+  }
+};
+
+// src/drivers/instagram-driver.ts
+var InstagramDriver = class extends BaseDriver {
+  platform = "instagram";
+  label = "Instagram";
+  icon = "\u{1F4F7}";
+  postizProvider = "instagram";
+  getMaxLength() {
+    return 2200;
+  }
+  getSupportedMedia() {
+    return ["image/jpeg", "image/png", "video/mp4"];
+  }
+};
+
+// src/drivers/facebook-driver.ts
+var FacebookDriver = class extends BaseDriver {
+  platform = "facebook";
+  label = "Facebook";
+  icon = "\u{1F4D8}";
+  postizProvider = "facebook";
+  getMaxLength() {
+    return 63206;
+  }
+  getSupportedMedia() {
+    return ["image/jpeg", "image/png", "image/gif", "video/mp4"];
+  }
+};
+
+// src/drivers/linkedin-driver.ts
+var LinkedInDriver = class extends BaseDriver {
+  platform = "linkedin";
+  label = "LinkedIn";
+  icon = "\u{1F4BC}";
+  postizProvider = "linkedin";
+  getMaxLength() {
+    return 3e3;
+  }
+  getSupportedMedia() {
+    return ["image/jpeg", "image/png", "image/gif", "video/mp4"];
+  }
+};
+
+// src/drivers/tiktok-driver.ts
+var TikTokDriver = class extends BaseDriver {
+  platform = "tiktok";
+  label = "TikTok";
+  icon = "\u{1F3B5}";
+  postizProvider = "tiktok";
+  getMaxLength() {
+    return 2200;
+  }
+  getSupportedMedia() {
+    return ["video/mp4"];
+  }
+};
+
+// src/drivers/discord-driver.ts
+var DiscordDriver = class extends BaseDriver {
+  platform = "discord";
+  label = "Discord";
+  icon = "\u{1F4AC}";
+  postizProvider = "discord";
+  getMaxLength() {
+    return 2e3;
+  }
+  /** Discord posting via OpenClaw gateway message tool */
+  async publishViaGateway(content) {
+    return {
+      success: false,
+      error: "Gateway publishing requires OpenClaw message routing \u2014 use the scheduler or workflow"
+    };
+  }
+};
+
+// src/drivers/telegram-driver.ts
+var TelegramDriver = class extends BaseDriver {
+  platform = "telegram";
+  label = "Telegram";
+  icon = "\u2708\uFE0F";
+  postizProvider = "telegram";
+  getMaxLength() {
+    return 4096;
+  }
+  /** Telegram posting via OpenClaw gateway message tool */
+  async publishViaGateway(content) {
+    return {
+      success: false,
+      error: "Gateway publishing requires OpenClaw message routing \u2014 use the scheduler or workflow"
+    };
+  }
+};
+
+// src/drivers/index.ts
+var DRIVER_MAP = {
+  x: XDriver,
+  twitter: XDriver,
+  instagram: InstagramDriver,
+  facebook: FacebookDriver,
+  linkedin: LinkedInDriver,
+  tiktok: TikTokDriver,
+  discord: DiscordDriver,
+  telegram: TelegramDriver
+};
+function getPlatforms() {
+  return ["x", "instagram", "facebook", "linkedin", "tiktok", "discord", "telegram"];
+}
+function createDriver(platform, config) {
+  const Cls = DRIVER_MAP[platform.toLowerCase()];
+  if (!Cls) return null;
+  return new Cls(config);
+}
+function createAllDrivers(sources) {
+  const platforms = getPlatforms();
+  const drivers = [];
+  for (const platform of platforms) {
+    const config = {};
+    if (sources.postiz) {
+      config.postiz = {
+        apiKey: sources.postiz.apiKey,
+        baseUrl: sources.postiz.baseUrl
+      };
+    }
+    if (sources.gatewayChannels?.includes(platform)) {
+      config.gateway = { channel: platform };
+    }
+    const stored = sources.storedAccounts?.find((a) => a.platform === platform);
+    if (stored) {
+      config.direct = stored.credentials;
+    }
+    const driver = createDriver(platform, config);
+    if (driver) drivers.push(driver);
+  }
+  return drivers;
+}
+
 // src/api/handler.ts
 function apiError(status, error, message, details) {
   const payload = { error, message, details };
@@ -224,139 +536,151 @@ function getTeamId(req) {
 function getUserId(req) {
   return req.headers["x-user-id"] || "system";
 }
-function getPostizConfig(req) {
-  const apiKey = req.query.postizApiKey || req.headers["x-postiz-api-key"];
-  const baseUrl = req.query.postizBaseUrl || req.headers["x-postiz-base-url"] || "https://api.postiz.com/public/v1";
-  if (!apiKey) return null;
-  return { apiKey, baseUrl: baseUrl.replace(/\/+$/, "") };
-}
-async function postizFetch(config, path, options) {
-  return fetch(`${config.baseUrl}${path}`, {
-    ...options,
-    headers: {
-      "Authorization": config.apiKey,
-      "Content-Type": "application/json",
-      ...options?.headers || {}
-    }
-  });
-}
-async function detectProviders(req, teamId) {
-  const providers = [];
-  const postizCfg = getPostizConfig(req);
-  if (postizCfg) {
-    try {
-      const res = await postizFetch(postizCfg, "/integrations");
-      if (res.ok) {
-        const data = await res.json();
-        const integrations = Array.isArray(data) ? data : data.integrations || [];
-        for (const integ of integrations) {
-          providers.push({
-            id: `postiz:${integ.id}`,
-            type: "postiz",
-            platform: integ.providerIdentifier || integ.provider || "unknown",
-            displayName: integ.name || integ.providerIdentifier || "Postiz account",
-            username: integ.username || void 0,
-            avatar: integ.picture || integ.avatar || void 0,
-            isActive: !integ.disabled,
-            capabilities: ["post", "schedule"],
-            meta: { postizId: integ.id, provider: integ.providerIdentifier }
-          });
-        }
-      }
-    } catch {
-    }
+function getBackendSources(req, teamId) {
+  const sources = {};
+  const postizKey = req.query.postizApiKey || req.headers["x-postiz-api-key"];
+  if (postizKey) {
+    const baseUrl = req.query.postizBaseUrl || req.headers["x-postiz-base-url"] || "https://api.postiz.com/public/v1";
+    sources.postiz = { apiKey: postizKey, baseUrl: baseUrl.replace(/\/+$/, "") };
   }
   try {
-    const fs = await import("fs");
-    const path = await import("path");
-    const os = await import("os");
+    const fs = require("fs");
+    const path = require("path");
+    const os = require("os");
     const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
     if (fs.existsSync(configPath)) {
       const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
       const plugins = cfg?.plugins?.entries || {};
-      if (plugins.discord?.enabled) {
-        providers.push({
-          id: "gateway:discord",
-          type: "gateway",
-          platform: "discord",
-          displayName: "Discord (via OpenClaw)",
-          isActive: true,
-          capabilities: ["post"],
-          meta: { channel: "discord" }
-        });
-      }
-      if (plugins.telegram?.enabled) {
-        providers.push({
-          id: "gateway:telegram",
-          type: "gateway",
-          platform: "telegram",
-          displayName: "Telegram (via OpenClaw)",
-          isActive: true,
-          capabilities: ["post"],
-          meta: { channel: "telegram" }
-        });
-      }
+      const channels = [];
+      if (plugins.discord?.enabled) channels.push("discord");
+      if (plugins.telegram?.enabled) channels.push("telegram");
+      sources.gatewayChannels = channels;
     }
   } catch {
   }
-  return providers;
-}
-async function postizPublish(config, body) {
-  const payload = {
-    content: body.content,
-    integrationIds: body.integrationIds
-  };
-  if (body.scheduledAt) {
-    payload.date = body.scheduledAt;
-  }
-  if (body.settings) {
-    payload.settings = body.settings;
-  }
-  if (body.mediaUrls && body.mediaUrls.length > 0) {
-    payload.media = body.mediaUrls.map((url) => ({ url }));
-  }
-  const res = await postizFetch(config, "/posts", {
-    method: "POST",
-    body: JSON.stringify(payload)
-  });
-  const data = await res.json().catch(() => null);
-  if (!res.ok) {
-    return apiError(res.status, "POSTIZ_ERROR", data?.message || `Postiz returned ${res.status}`, data);
+  try {
+    const { db } = initializeDatabase(teamId);
+    const accounts = db.select().from(socialAccounts).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(socialAccounts.teamId, teamId), (0, import_drizzle_orm2.eq)(socialAccounts.isActive, true))).all();
+    sources.storedAccounts = accounts.map((a) => ({
+      platform: a.platform,
+      credentials: decryptCredentials(a.credentials)
+    }));
+  } catch {
   }
-  return { status: 201, data };
+  return sources;
 }
 async function handleRequest(req, ctx) {
   const teamId = getTeamId(req);
-  if (req.path === "/providers" && req.method === "GET") {
+  if (req.path === "/drivers" && req.method === "GET") {
     try {
-      const providers = await detectProviders(req, teamId);
-      return { status: 200, data: { providers } };
+      const sources = getBackendSources(req, teamId);
+      const drivers = createAllDrivers(sources);
+      const results = await Promise.all(
+        drivers.map(async (d) => {
+          const status = await d.getStatus();
+          const caps = d.getCapabilities();
+          return {
+            platform: d.platform,
+            label: d.label,
+            icon: d.icon,
+            ...status,
+            capabilities: caps
+          };
+        })
+      );
+      return { status: 200, data: { drivers: results } };
     } catch (error) {
-      return apiError(500, "DETECT_ERROR", error?.message || "Failed to detect providers");
+      return apiError(500, "DRIVER_ERROR", error?.message || "Failed to load drivers");
     }
   }
-  if (req.path === "/providers/postiz/integrations" && req.method === "GET") {
-    const postizCfg = getPostizConfig(req);
-    if (!postizCfg) return apiError(400, "NO_POSTIZ", "Postiz API key not configured");
-    try {
-      const res = await postizFetch(postizCfg, "/integrations");
-      const data = await res.json();
-      return { status: res.status, data };
-    } catch (error) {
-      return apiError(502, "POSTIZ_UNREACHABLE", error?.message || "Cannot reach Postiz");
-    }
+  if (req.path.match(/^\/drivers\/([^/]+)\/status$/) && req.method === "GET") {
+    const platform = req.path.split("/")[2];
+    const sources = getBackendSources(req, teamId);
+    const driver = createDriver(platform, {
+      postiz: sources.postiz,
+      gateway: sources.gatewayChannels?.includes(platform) ? { channel: platform } : void 0,
+      direct: sources.storedAccounts?.find((a) => a.platform === platform)?.credentials
+    });
+    if (!driver) return apiError(404, "NOT_FOUND", `No driver for platform: ${platform}`);
+    const status = await driver.getStatus();
+    const caps = driver.getCapabilities();
+    return { status: 200, data: { platform, ...status, capabilities: caps } };
   }
   if (req.path === "/publish" && req.method === "POST") {
-    const postizCfg = getPostizConfig(req);
-    if (!postizCfg) return apiError(400, "NO_POSTIZ", "Postiz API key not configured");
-    const body = req.body || {};
-    if (!body.content || !body.integrationIds?.length) {
-      return apiError(400, "VALIDATION_ERROR", "content and integrationIds are required");
+    const body = req.body;
+    if (!body?.content || !body?.platforms?.length) {
+      return apiError(400, "VALIDATION_ERROR", "content and platforms[] are required");
+    }
+    const sources = getBackendSources(req, teamId);
+    const results = [];
+    for (const platform of body.platforms) {
+      const driver = createDriver(platform, {
+        postiz: sources.postiz,
+        gateway: sources.gatewayChannels?.includes(platform) ? { channel: platform } : void 0,
+        direct: sources.storedAccounts?.find((a) => a.platform === platform)?.credentials
+      });
+      if (!driver) {
+        results.push({ platform, success: false, error: `No driver for ${platform}` });
+        continue;
+      }
+      const status = await driver.getStatus();
+      if (!status.connected) {
+        results.push({ platform, success: false, error: `Not connected`, backend: status.backend });
+        continue;
+      }
+      const postContent = {
+        text: body.content,
+        mediaUrls: body.mediaUrls,
+        scheduledAt: body.scheduledAt,
+        settings: body.settings?.[platform]
+      };
+      const result = await driver.publish(postContent);
+      results.push({
+        platform,
+        success: result.success,
+        postId: result.postId,
+        error: result.error,
+        backend: status.backend
+      });
     }
+    const allOk = results.every((r) => r.success);
+    return { status: allOk ? 201 : 207, data: { results } };
+  }
+  if (req.path === "/platforms" && req.method === "GET") {
+    const sources = getBackendSources(req, teamId);
+    const drivers = createAllDrivers(sources);
+    const platforms = drivers.map((d) => ({
+      platform: d.platform,
+      label: d.label,
+      icon: d.icon,
+      capabilities: d.getCapabilities()
+    }));
+    return { status: 200, data: { platforms } };
+  }
+  if (req.path === "/providers" && req.method === "GET") {
     try {
-      return await postizPublish(postizCfg, body);
+      const sources = getBackendSources(req, teamId);
+      const drivers = createAllDrivers(sources);
+      const providers = await Promise.all(
+        drivers.map(async (d) => {
+          const status = await d.getStatus();
+          if (!status.connected) return null;
+          return {
+            id: `${status.backend}:${d.platform}`,
+            type: status.backend,
+            platform: d.platform,
+            displayName: status.displayName,
+            username: status.username,
+            avatar: status.avatar,
+            isActive: status.connected,
+            capabilities: status.backend === "postiz" ? ["post", "schedule"] : ["post"],
+            meta: { integrationId: status.integrationId }
+          };
+        })
+      );
+      return { status: 200, data: { providers: providers.filter(Boolean) } };
     } catch (error) {
-      return apiError(502, "POSTIZ_ERROR", error?.message || "Publish failed");
+      return apiError(500, "DETECT_ERROR", error?.message || "Failed to detect providers");
     }
   }
   if (req.path === "/posts" && req.method === "GET") {
@@ -364,12 +688,8 @@ async function handleRequest(req, ctx) {
       const { db } = initializeDatabase(teamId);
       const { limit, offset } = parsePagination(req.query);
       const conditions = [(0, import_drizzle_orm2.eq)(posts.teamId, teamId)];
-      if (req.query.status) {
-        conditions.push((0, import_drizzle_orm2.eq)(posts.status, String(req.query.status)));
-      }
-      if (req.query.platform) {
-        conditions.push((0, import_drizzle_orm2.like)(posts.platforms, `%"${req.query.platform}"%`));
-      }
+      if (req.query.status) conditions.push((0, import_drizzle_orm2.eq)(posts.status, String(req.query.status)));
+      if (req.query.platform) conditions.push((0, import_drizzle_orm2.like)(posts.platforms, `%"${req.query.platform}"%`));
       const totalResult = await db.select({ count: import_drizzle_orm2.sql`count(*)` }).from(posts).where((0, import_drizzle_orm2.and)(...conditions));
       const total = totalResult[0]?.count ?? 0;
       const posts2 = await db.select().from(posts).where((0, import_drizzle_orm2.and)(...conditions)).orderBy((0, import_drizzle_orm2.desc)(posts.createdAt)).limit(limit).offset(offset);