heyhank 0.1.0

package/server/socialmedia/adapters/postiz-adapter.ts

@@ -0,0 +1,298 @@
+// ─── Postiz Adapter ──────────────────────────────────────────────────────────
+// REST client for Postiz Public API v1.
+// Works with both hosted (api.postiz.com) and self-hosted instances.
+// Auth: raw API key in Authorization header (no Bearer prefix).
+// API key found at: Settings → Developers → Public API
+
+import type { SocialMediaAdapter } from "../adapter.js";
+import type { SocialProfile, CreatePostInput, PostAnalytics, AccountAnalytics, SocialComment, SocialPlatform } from "../types.js";
+
+const HOSTED_API = "https://api.postiz.com";
+
+// Postiz uses different identifiers than our standard platform names
+const PLATFORM_TO_POSTIZ: Record<string, string> = {
+  twitter: "x",
+  instagram: "instagram",
+  linkedin: "linkedin",
+  facebook: "facebook",
+  tiktok: "tiktok",
+  threads: "threads",
+};
+
+const POSTIZ_TO_PLATFORM: Record<string, SocialPlatform> = {
+  x: "twitter",
+  instagram: "instagram",
+  linkedin: "linkedin",
+  facebook: "facebook",
+  tiktok: "tiktok",
+  threads: "threads",
+};
+
+export class PostizAdapter implements SocialMediaAdapter {
+  private baseUrl: string;
+  private apiKey: string;
+  /** Cached integrations (channel list) */
+  private integrations: Array<{ id: string; name: string; identifier: string; picture: string | null }> | null = null;
+
+  private apiPrefix: string;
+
+  constructor(config: { url?: string; apiKey: string }) {
+    const raw = (config.url || HOSTED_API).replace(/\/+$/, "");
+    // Ensure we point to the API base, not the frontend
+    this.baseUrl = raw.includes("/public/v1") ? raw.replace(/\/public\/v1.*/, "") : raw;
+    // Hosted (api.postiz.com) uses /public/v1, self-hosted uses /api/public/v1
+    this.apiPrefix = raw === HOSTED_API || !config.url ? "/public/v1" : "/api/public/v1";
+    this.apiKey = config.apiKey;
+  }
+
+  private url(path: string): string {
+    return `${this.baseUrl}${this.apiPrefix}${path}`;
+  }
+
+  private headers(): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": this.apiKey,
+    };
+  }
+
+  // ─── Connection ─────────────────────────────────────────────────────────────
+
+  async testConnection(): Promise<{ ok: boolean; error?: string; data?: unknown }> {
+    try {
+      const res = await fetch(this.url("/is-connected"), { headers: this.headers() });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return { ok: false, error: `Postiz returned ${res.status}: ${text || res.statusText}` };
+      }
+      const data = await res.json();
+      if (data.connected) {
+        return { ok: true, data };
+      }
+      return { ok: false, error: "Not connected" };
+    } catch (err: any) {
+      return { ok: false, error: err?.message ?? "Connection failed" };
+    }
+  }
+
+  // ─── Integrations / Profiles ────────────────────────────────────────────────
+
+  private async loadIntegrations(): Promise<typeof this.integrations> {
+    if (this.integrations) return this.integrations;
+    try {
+      const res = await fetch(this.url("/integrations"), { headers: this.headers() });
+      if (!res.ok) return [];
+      const data = await res.json();
+      this.integrations = (Array.isArray(data) ? data : []).map((item: any) => ({
+        id: item.id ?? "",
+        name: item.name ?? item.profile ?? item.identifier ?? "",
+        identifier: item.identifier ?? "",
+        picture: item.picture ?? null,
+      }));
+      return this.integrations;
+    } catch {
+      return [];
+    }
+  }
+
+  async getProfiles(): Promise<SocialProfile[]> {
+    const integrations = await this.loadIntegrations();
+    return (integrations || []).map((item) => ({
+      id: item.id,
+      platform: (POSTIZ_TO_PLATFORM[item.identifier] ?? item.identifier) as SocialPlatform,
+      name: item.name,
+      picture: item.picture,
+    }));
+  }
+
+  supportedPlatforms(): SocialPlatform[] {
+    return ["twitter", "instagram", "linkedin", "facebook", "tiktok", "threads"];
+  }
+
+  // ─── Posts ──────────────────────────────────────────────────────────────────
+
+  async createPost(input: CreatePostInput): Promise<{ id: string | null; status: string; backendData?: unknown }> {
+    try {
+      const integrations = await this.loadIntegrations();
+
+      // Resolve integration IDs for selected platforms
+      const matchedIntegrations = (integrations || []).filter((ig) => {
+        const platform = POSTIZ_TO_PLATFORM[ig.identifier];
+        return platform && input.platforms.includes(platform);
+      });
+
+      if (matchedIntegrations.length === 0) {
+        return { id: null, status: "failed", backendData: { error: "No connected integrations match the selected platforms" } };
+      }
+
+      // Upload media from URLs if present
+      const mediaItems: Array<{ id: string; path: string }> = [];
+      if (input.mediaUrls?.length) {
+        for (const mediaUrl of input.mediaUrls) {
+          try {
+            const uploadRes = await fetch(this.url("/upload-from-url"), {
+              method: "POST",
+              headers: this.headers(),
+              body: JSON.stringify({ url: mediaUrl }),
+            });
+            if (uploadRes.ok) {
+              const uploadData = await uploadRes.json();
+              if (uploadData.id && uploadData.path) {
+                mediaItems.push({ id: uploadData.id, path: uploadData.path });
+              }
+            }
+          } catch {
+            // Skip failed uploads
+          }
+        }
+      }
+
+      // Build post payload per Postiz API
+      const postEntries = matchedIntegrations.map((ig) => ({
+        integration: { id: ig.id },
+        value: [{
+          content: input.text,
+          image: mediaItems,
+        }],
+        settings: { __type: ig.identifier },
+      }));
+
+      const body: Record<string, unknown> = {
+        type: input.scheduledAt ? "schedule" : "now",
+        date: input.scheduledAt || new Date().toISOString(),
+        shortLink: false,
+        posts: postEntries,
+      };
+
+      const res = await fetch(this.url("/posts"), {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(body),
+      });
+
+      const data = await res.json();
+      if (!res.ok) {
+        return { id: null, status: "failed", backendData: data };
+      }
+
+      return {
+        id: data.id ?? data.groupId ?? null,
+        status: input.scheduledAt ? "scheduled" : "published",
+        backendData: data,
+      };
+    } catch (err: any) {
+      return { id: null, status: "failed", backendData: { error: err?.message } };
+    }
+  }
+
+  async listPosts(opts?: { limit?: number }): Promise<Array<{ id: string; text: string; status: string; platforms: string[]; createdAt?: string | null; scheduledAt?: string | null }>> {
+    try {
+      // Postiz requires startDate/endDate
+      const now = new Date();
+      const endDate = new Date(now.getTime() + 30 * 86400000).toISOString(); // +30 days
+      const startDate = new Date(now.getTime() - 90 * 86400000).toISOString(); // -90 days
+
+      const res = await fetch(
+        this.url(`/posts?startDate=${encodeURIComponent(startDate)}&endDate=${encodeURIComponent(endDate)}`),
+        { headers: this.headers() },
+      );
+      if (!res.ok) return [];
+
+      const data = await res.json();
+      const posts = Array.isArray(data) ? data : data.posts ?? [];
+      const limit = opts?.limit ?? 50;
+
+      const STATE_MAP: Record<string, string> = {
+        QUEUE: "scheduled",
+        PUBLISHED: "published",
+        ERROR: "failed",
+        DRAFT: "draft",
+      };
+
+      return posts.slice(0, limit).map((p: any) => ({
+        id: p.id ?? "",
+        text: p.content ?? "",
+        status: STATE_MAP[p.state] ?? p.state?.toLowerCase() ?? "unknown",
+        platforms: p.integration?.identifier
+          ? [POSTIZ_TO_PLATFORM[p.integration.identifier] ?? p.integration.identifier]
+          : [],
+        createdAt: p.createdAt ?? null,
+        scheduledAt: p.publishDate ?? null,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async deletePost(postId: string): Promise<boolean> {
+    try {
+      const res = await fetch(this.url(`/posts/${postId}`), {
+        method: "DELETE",
+        headers: this.headers(),
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  // ─── Analytics ──────────────────────────────────────────────────────────────
+
+  async getAnalytics(postId: string): Promise<PostAnalytics> {
+    try {
+      const res = await fetch(this.url(`/analytics/post/${postId}?date=30`), { headers: this.headers() });
+      if (!res.ok) return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+      const data = await res.json();
+      if (data.missing) return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+
+      // Postiz returns array of { label, data: [{total, date}], percentageChange }
+      const metrics = Array.isArray(data) ? data : [];
+      const getValue = (label: string) => {
+        const m = metrics.find((x: any) => x.label?.toLowerCase().includes(label));
+        return m?.data?.reduce((sum: number, d: any) => sum + (parseInt(d.total) || 0), 0) ?? 0;
+      };
+
+      return {
+        impressions: getValue("impression") || getValue("reach") || getValue("view"),
+        likes: getValue("like") || getValue("favorite"),
+        shares: getValue("share") || getValue("retweet") || getValue("repost"),
+        comments: getValue("comment") || getValue("reply"),
+      };
+    } catch {
+      return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+    }
+  }
+
+  async getAccountAnalytics(profileId: string): Promise<AccountAnalytics> {
+    try {
+      const res = await fetch(this.url(`/analytics/${profileId}?date=30`), { headers: this.headers() });
+      if (!res.ok) return { followers: 0, following: 0, posts: 0 };
+      const data = await res.json();
+
+      const metrics = Array.isArray(data) ? data : [];
+      const getLatest = (label: string) => {
+        const m = metrics.find((x: any) => x.label?.toLowerCase().includes(label));
+        const latest = m?.data?.[m.data.length - 1];
+        return parseInt(latest?.total) || 0;
+      };
+
+      return {
+        followers: getLatest("follower"),
+        following: getLatest("following"),
+        posts: getLatest("post") || getLatest("tweet"),
+      };
+    } catch {
+      return { followers: 0, following: 0, posts: 0 };
+    }
+  }
+
+  // ─── Comments (not supported by Postiz API) ────────────────────────────────
+
+  async getComments(_postId: string): Promise<SocialComment[]> {
+    return [];
+  }
+
+  async replyToComment(_postId: string, _commentId: string | null, _text: string): Promise<{ ok: boolean; error?: string }> {
+    return { ok: false, error: "Postiz does not support comment management via API" };
+  }
+}

package/server/socialmedia/manager.ts

@@ -0,0 +1,227 @@
+// ─── Social Media Manager ────────────────────────────────────────────────────
+// Business logic layer for social media operations.
+
+import { randomUUID } from "node:crypto";
+import type { SocialMediaAdapter } from "./adapter.js";
+import type {
+  SocialMediaSettings,
+  SocialPost,
+  CreatePostInput,
+  PostAnalytics,
+  AccountAnalytics,
+  SocialComment,
+  SocialProfile,
+  ListPostsOpts,
+} from "./types.js";
+import * as store from "./store.js";
+
+let cachedAdapter: SocialMediaAdapter | null = null;
+let cachedBackendKey: string | null = null;
+
+export async function getAdapter(settings?: SocialMediaSettings): Promise<SocialMediaAdapter> {
+  const s = settings ?? store.getSettings();
+  if (!s.backend) {
+    throw new Error("No social media backend configured");
+  }
+
+  const config = s.backends[s.backend];
+  if (!config) {
+    throw new Error(`No configuration found for backend: ${s.backend}`);
+  }
+
+  // Cache adapter if same backend + config
+  const key = `${s.backend}:${config.apiKey}:${config.url ?? ""}`;
+  if (cachedAdapter && cachedBackendKey === key) {
+    return cachedAdapter;
+  }
+
+  let adapter: SocialMediaAdapter;
+
+  switch (s.backend) {
+    case "postiz": {
+      const { PostizAdapter } = await import("./adapters/postiz-adapter.js");
+      adapter = new PostizAdapter({ url: config.url ?? "", apiKey: config.apiKey });
+      break;
+    }
+    case "ayrshare": {
+      const { AyrshareAdapter } = await import("./adapters/ayrshare-adapter.js");
+      adapter = new AyrshareAdapter({ apiKey: config.apiKey });
+      break;
+    }
+    case "buffer": {
+      const { BufferAdapter } = await import("./adapters/buffer-adapter.js");
+      adapter = new BufferAdapter({ apiKey: config.apiKey });
+      break;
+    }
+    default:
+      throw new Error(`Unknown social media backend: ${s.backend}`);
+  }
+
+  cachedAdapter = adapter;
+  cachedBackendKey = key;
+  return adapter;
+}
+
+export async function testConnection(): Promise<{ ok: boolean; error?: string; data?: unknown }> {
+  try {
+    const adapter = await getAdapter();
+    return await adapter.testConnection();
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? "Unknown error" };
+  }
+}
+
+export async function getProfiles(): Promise<SocialProfile[]> {
+  const adapter = await getAdapter();
+  return adapter.getProfiles();
+}
+
+export async function createPost(input: CreatePostInput): Promise<SocialPost> {
+  const settings = store.getSettings();
+  const now = new Date().toISOString();
+
+  const post: SocialPost = {
+    id: randomUUID(),
+    text: input.text,
+    platforms: input.platforms,
+    scheduledAt: input.scheduledAt ?? null,
+    mediaUrls: input.mediaUrls ?? [],
+    status: "draft",
+    backendId: settings.backend,
+    backendPostId: null,
+    createdAt: now,
+    updatedAt: now,
+    title: input.title,
+    firstComment: input.firstComment,
+    videoUrl: input.videoUrl,
+    thumbnailUrl: input.thumbnailUrl,
+  };
+
+  // If isDraft, save locally and return without calling backend
+  if (input.isDraft) {
+    post.backendId = null;
+    store.savePost(post);
+    return post;
+  }
+
+  try {
+    const adapter = await getAdapter(settings);
+    const result = await adapter.createPost(input);
+    post.backendPostId = result.id;
+    post.status = result.status as SocialPost["status"];
+    post.backendData = result.backendData;
+  } catch (err: any) {
+    post.status = "failed";
+    post.backendData = { error: err?.message };
+  }
+
+  post.updatedAt = new Date().toISOString();
+  store.savePost(post);
+  return post;
+}
+
+export async function listPosts(opts?: ListPostsOpts): Promise<SocialPost[]> {
+  return store.listLocalPosts(opts);
+}
+
+export function getPost(id: string): SocialPost | null {
+  return store.getPost(id);
+}
+
+export async function deletePost(id: string): Promise<boolean> {
+  const post = store.getPost(id);
+  if (!post) return false;
+
+  // Try to delete from backend if we have a backend post ID
+  if (post.backendPostId) {
+    try {
+      const adapter = await getAdapter();
+      await adapter.deletePost(post.backendPostId);
+    } catch {
+      // Continue with local deletion even if backend fails
+    }
+  }
+
+  return store.deleteLocalPost(id);
+}
+
+export async function getPostAnalytics(id: string): Promise<PostAnalytics> {
+  const post = store.getPost(id);
+  if (!post?.backendPostId) {
+    return { impressions: 0, likes: 0, shares: 0, comments: 0 };
+  }
+  const adapter = await getAdapter();
+  return adapter.getAnalytics(post.backendPostId);
+}
+
+export async function getAccountAnalytics(profileId: string): Promise<AccountAnalytics> {
+  const adapter = await getAdapter();
+  return adapter.getAccountAnalytics(profileId);
+}
+
+export async function getComments(postId: string): Promise<SocialComment[]> {
+  const post = store.getPost(postId);
+  if (!post?.backendPostId) return [];
+  const adapter = await getAdapter();
+  return adapter.getComments(post.backendPostId);
+}
+
+export async function replyToComment(postId: string, commentId: string | null, text: string): Promise<{ ok: boolean; error?: string }> {
+  const post = store.getPost(postId);
+  if (!post?.backendPostId) {
+    return { ok: false, error: "Post not found or has no backend ID" };
+  }
+  const adapter = await getAdapter();
+  return adapter.replyToComment(post.backendPostId, commentId, text);
+}
+
+export async function createDraft(input: CreatePostInput & { createdBy?: "user" | "gemini" | "agent" }): Promise<SocialPost> {
+  const now = new Date().toISOString();
+  const post: SocialPost = {
+    id: randomUUID(),
+    text: input.text,
+    platforms: input.platforms,
+    scheduledAt: input.scheduledAt ?? null,
+    mediaUrls: input.mediaUrls ?? [],
+    status: "draft",
+    backendId: null,
+    backendPostId: null,
+    createdAt: now,
+    updatedAt: now,
+    title: input.title,
+    firstComment: input.firstComment,
+    videoUrl: input.videoUrl,
+    thumbnailUrl: input.thumbnailUrl,
+    createdBy: input.createdBy ?? "user",
+  };
+  store.savePost(post);
+  return post;
+}
+
+export async function publishDraft(id: string): Promise<SocialPost> {
+  const post = store.getPost(id);
+  if (!post) throw new Error("Post not found");
+  if (post.status !== "draft") throw new Error("Post is not a draft");
+
+  const settings = store.getSettings();
+  try {
+    const adapter = await getAdapter(settings);
+    const result = await adapter.createPost({
+      text: post.text,
+      platforms: post.platforms,
+      scheduledAt: post.scheduledAt,
+      mediaUrls: post.mediaUrls,
+    });
+    post.backendId = settings.backend;
+    post.backendPostId = result.id;
+    post.status = result.status as SocialPost["status"];
+    post.backendData = result.backendData;
+  } catch (err: any) {
+    post.status = "failed";
+    post.backendData = { error: err?.message };
+  }
+
+  post.updatedAt = new Date().toISOString();
+  store.savePost(post);
+  return post;
+}

package/server/socialmedia/store.ts

@@ -0,0 +1,98 @@
+// ─── Social Media Store ──────────────────────────────────────────────────────
+// File-based persistence for social media settings and posts.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { SocialMediaSettings, SocialPost, ListPostsOpts } from "./types.js";
+import { DEFAULT_SOCIAL_SETTINGS } from "./types.js";
+
+const BASE_DIR = join(homedir(), ".heyhank", "socialmedia");
+const SETTINGS_FILE = join(BASE_DIR, "settings.json");
+const POSTS_DIR = join(BASE_DIR, "posts");
+
+function ensureDirs(): void {
+  if (!existsSync(BASE_DIR)) mkdirSync(BASE_DIR, { recursive: true });
+  if (!existsSync(POSTS_DIR)) mkdirSync(POSTS_DIR, { recursive: true });
+}
+
+// ─── Settings ────────────────────────────────────────────────────────────────
+
+export function getSettings(): SocialMediaSettings {
+  ensureDirs();
+  if (!existsSync(SETTINGS_FILE)) return { ...DEFAULT_SOCIAL_SETTINGS };
+  try {
+    const raw = readFileSync(SETTINGS_FILE, "utf-8");
+    return { ...DEFAULT_SOCIAL_SETTINGS, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_SOCIAL_SETTINGS };
+  }
+}
+
+export function saveSettings(settings: SocialMediaSettings): void {
+  ensureDirs();
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), { encoding: "utf-8", mode: 0o600 });
+}
+
+// ─── Posts ───────────────────────────────────────────────────────────────────
+
+export function savePost(post: SocialPost): void {
+  ensureDirs();
+  if (!post.id) {
+    post.id = randomUUID();
+  }
+  const file = join(POSTS_DIR, `${post.id}.json`);
+  writeFileSync(file, JSON.stringify(post, null, 2), "utf-8");
+}
+
+export function getPost(postId: string): SocialPost | null {
+  const file = join(POSTS_DIR, `${postId}.json`);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function listLocalPosts(opts?: ListPostsOpts): SocialPost[] {
+  ensureDirs();
+  const limit = opts?.limit ?? 50;
+  try {
+    const files = readdirSync(POSTS_DIR)
+      .filter((f) => f.endsWith(".json"))
+      .sort()
+      .reverse();
+
+    let posts = files.map((f) => {
+      try {
+        return JSON.parse(readFileSync(join(POSTS_DIR, f), "utf-8")) as SocialPost;
+      } catch {
+        return null;
+      }
+    }).filter(Boolean) as SocialPost[];
+
+    if (opts?.status) {
+      posts = posts.filter((p) => p.status === opts.status);
+    }
+    if (opts?.platform) {
+      posts = posts.filter((p) => p.platforms.includes(opts.platform as any));
+    }
+
+    return posts.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+
+export function deleteLocalPost(postId: string): boolean {
+  const file = join(POSTS_DIR, `${postId}.json`);
+  if (!existsSync(file)) return false;
+  try {
+    unlinkSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}