heyhank 0.1.0 → 0.2.0

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

@@ -4,8 +4,160 @@
 // Auth: raw API key in Authorization header (no Bearer prefix).
 // API key found at: Settings → Developers → Public API
 
+import { readFileSync, existsSync } from "node:fs";
+import { basename, join } from "node:path";
+import sharp from "sharp";
 import type { SocialMediaAdapter } from "../adapter.js";
 import type { SocialProfile, CreatePostInput, PostAnalytics, AccountAnalytics, SocialComment, SocialPlatform } from "../types.js";
+import { getSettings as getAppSettings } from "../../settings-manager.js";
+import { HEYHANK_HOME } from "../../paths.js";
+
+const MIME_BY_EXT: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+};
+
+/**
+ * Detect the true MIME type from the file's magic bytes. Some generators
+ * (e.g. Google's nanobanana MCP) save JPEG content under a `.png` filename,
+ * which causes IG/X/Meta to reject the post because the declared content
+ * type doesn't match the actual bytes. Always trust the bytes over the name.
+ * Returns null if no known signature matches — caller falls back to extension.
+ */
+function detectMimeFromBytes(buf: Uint8Array): string | null {
+  if (buf.length < 12) return null;
+  // JPEG: FF D8 FF
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) return "image/jpeg";
+  // PNG: 89 50 4E 47 0D 0A 1A 0A
+  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return "image/png";
+  // GIF: 47 49 46 38
+  if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x38) return "image/gif";
+  // WebP: RIFF....WEBP
+  if (buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46
+      && buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50) return "image/webp";
+  // MP4 (ISO BMFF): bytes 4-7 = "ftyp"
+  if (buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70) return "video/mp4";
+  return null;
+}
+
+// Instagram feed aspect ratio bounds (width / height).
+// Spec is [0.8, 1.91] but we leave a safety margin to avoid rejections at
+// the exact boundary (Instagram occasionally rounds and rejects 0.800).
+const IG_ASPECT_MIN = 0.81;
+const IG_ASPECT_MAX = 1.90;
+
+// Canonical IG sizes — pad/resize to one of these so IG always accepts the
+// container creation request.
+const IG_PORTRAIT_W = 1080;
+const IG_PORTRAIT_H = 1350; // 4:5
+const IG_SQUARE = 1080;
+const IG_LANDSCAPE_W = 1080;
+const IG_LANDSCAPE_H = 566;  // ~1.91:1
+
+/**
+ * Normalize an image so Instagram's Graph API will accept it.
+ *
+ * Instagram returns the misleading error "Media fetch failed, please try
+ * again" (error code 2207052) for several distinct reasons, all of which
+ * we hit in practice:
+ *   1. Aspect ratio outside [0.8, 1.91] (NB2 default 896×1200 = 0.747).
+ *   2. JPEG written without a JFIF/Exif APP marker (Sharp's default
+ *      output via `.jpeg()` after `.extend()`).
+ *   3. Non-sRGB color space.
+ *
+ * To eliminate all three at once, we always re-encode through Sharp into
+ * a canonical IG size (1080×1350 portrait, 1080×1080 square, 1080×566
+ * landscape) as sRGB JPEG with explicit metadata. Padded background is
+ * white. This is only invoked when Instagram is among the target
+ * platforms, so other platforms still see the user's original image.
+ */
+async function normalizeForInstagram(
+  buf: Buffer,
+  inMime: string,
+): Promise<{ buffer: Buffer; mime: string; changed: boolean }> {
+  if (!inMime.startsWith("image/")) return { buffer: buf, mime: inMime, changed: false };
+  // GIFs: IG doesn't accept GIF in feed, and Sharp would lose animation
+  // frames anyway. Pass through untouched.
+  if (inMime === "image/gif") return { buffer: buf, mime: inMime, changed: false };
+
+  const meta = await sharp(buf).metadata();
+  const w = meta.width ?? 0;
+  const h = meta.height ?? 0;
+  if (!w || !h) return { buffer: buf, mime: inMime, changed: false };
+
+  const aspect = w / h;
+
+  // Choose the closest canonical canvas based on the original aspect.
+  let targetW: number;
+  let targetH: number;
+  if (aspect < IG_ASPECT_MIN || aspect < 0.95) {
+    targetW = IG_PORTRAIT_W;
+    targetH = IG_PORTRAIT_H;
+  } else if (aspect > IG_ASPECT_MAX || aspect > 1.5) {
+    targetW = IG_LANDSCAPE_W;
+    targetH = IG_LANDSCAPE_H;
+  } else {
+    targetW = IG_SQUARE;
+    targetH = IG_SQUARE;
+  }
+
+  // `fit: contain` resizes the original to fit inside the target canvas
+  // and pads the rest with the background color (white). No cropping.
+  const out = await sharp(buf)
+    .resize({
+      width: targetW,
+      height: targetH,
+      fit: "contain",
+      background: { r: 255, g: 255, b: 255, alpha: 1 },
+    })
+    .toColorspace("srgb")
+    .jpeg({
+      quality: 90,
+      chromaSubsampling: "4:2:0",
+      // `force: true` guarantees JPEG output even if input was PNG/WebP.
+      force: true,
+    })
+    .withMetadata({ density: 72 })
+    .toBuffer();
+
+  return { buffer: out, mime: "image/jpeg", changed: true };
+}
+
+function extForMime(mime: string): string {
+  switch (mime) {
+    case "image/jpeg": return "jpg";
+    case "image/png": return "png";
+    case "image/gif": return "gif";
+    case "image/webp": return "webp";
+    case "video/mp4": return "mp4";
+    case "video/quicktime": return "mov";
+    case "video/webm": return "webm";
+    default: return "bin";
+  }
+}
+
+/**
+ * Detect URLs that point to HeyHank's own media route. Works for both
+ * absolute URLs (any host, e.g. the publicUrl) and relative paths.
+ * Returns the bare filename if matched, else null.
+ */
+function extractLocalMediaFilename(url: string): string | null {
+  try {
+    // Normalize: strip protocol+host if present
+    const withoutHost = url.replace(/^https?:\/\/[^/]+/i, "");
+    const match = withoutHost.match(/^\/api\/media\/file\/([^/?#]+)/);
+    if (!match) return null;
+    return basename(decodeURIComponent(match[1]));
+  } catch {
+    return null;
+  }
+}
 
 const HOSTED_API = "https://api.postiz.com";
 
@@ -125,42 +277,167 @@ export class PostizAdapter implements SocialMediaAdapter {
         return { id: null, status: "failed", backendData: { error: "No connected integrations match the selected platforms" } };
       }
 
-      // Upload media from URLs if present
+      // Upload media. Two paths:
+      //  1. Local HeyHank media (/api/media/file/<filename>): read from disk
+      //     and upload as multipart — avoids Postiz hitting our Basic-Auth
+      //     protected HTTP endpoint (which returns 500 / auth challenge).
+      //  2. Other URLs: use Postiz /upload-from-url so Postiz fetches directly.
+      const publicUrl = getAppSettings().publicUrl?.replace(/\/+$/, "") ?? "";
       const mediaItems: Array<{ id: string; path: string }> = [];
-      if (input.mediaUrls?.length) {
-        for (const mediaUrl of input.mediaUrls) {
+      const mediaUploadErrors: string[] = [];
+
+      for (const mediaUrl of input.mediaUrls ?? []) {
+        if (!mediaUrl) continue;
+
+        // ── Path 1: local media file ──────────────────────────────────────
+        const localFilename = extractLocalMediaFilename(mediaUrl);
+        if (localFilename) {
+          const localPath = join(HEYHANK_HOME, "media", localFilename);
+          if (!existsSync(localPath)) {
+            mediaUploadErrors.push(`Local media file not found: ${localFilename}`);
+            continue;
+          }
           try {
-            const uploadRes = await fetch(this.url("/upload-from-url"), {
+            const rawBuf = readFileSync(localPath);
+            const extFromName = localFilename.split(".").pop()?.toLowerCase() ?? "";
+            // Prefer magic-byte detection over extension. Some image generators
+            // (e.g. nanobanana MCP) save JPEG content with a `.png` name, which
+            // makes IG reject the post ("Media fetch failed") and X fail with
+            // "bad_body" because the declared vs actual format disagree.
+            const sniffedMime = detectMimeFromBytes(rawBuf);
+            const baseMime = sniffedMime ?? MIME_BY_EXT[extFromName] ?? "application/octet-stream";
+
+            // If Instagram is one of the targets, ensure the image aspect ratio
+            // is within IG's accepted range. NB2 generates 896×1200 (0.747:1)
+            // by default which IG rejects as "Media fetch failed". Pad to 4:5.
+            let fileBuf: Buffer = rawBuf;
+            let mime = baseMime;
+            let normalized = false;
+            if (input.platforms.includes("instagram")) {
+              const norm = await normalizeForInstagram(rawBuf, baseMime);
+              fileBuf = norm.buffer;
+              mime = norm.mime;
+              normalized = norm.changed;
+            }
+
+            // If the on-disk extension disagrees with the sniffed (or
+            // re-encoded) content, rename the upload filename to the correct
+            // extension so that Postiz / downstream CDNs serve it with a
+            // matching Content-Type.
+            const finalSniff = detectMimeFromBytes(fileBuf) ?? mime;
+            const correctExt = finalSniff ? extForMime(finalSniff) : extFromName;
+            const stem = localFilename.replace(/\.[^.]+$/, "");
+            const uploadName = normalized
+              ? `${stem}_ig${correctExt ? `.${correctExt}` : ""}`
+              : correctExt && correctExt !== extFromName
+                ? `${stem}.${correctExt}`
+                : localFilename;
+            const form = new FormData();
+            form.append("file", new Blob([new Uint8Array(fileBuf)], { type: mime }), uploadName);
+
+            // Do NOT set Content-Type — fetch/Blob sets the multipart boundary.
+            const uploadRes = await fetch(this.url("/upload"), {
               method: "POST",
-              headers: this.headers(),
-              body: JSON.stringify({ url: mediaUrl }),
+              headers: { Authorization: this.apiKey },
+              body: form,
             });
             if (uploadRes.ok) {
               const uploadData = await uploadRes.json();
               if (uploadData.id && uploadData.path) {
                 mediaItems.push({ id: uploadData.id, path: uploadData.path });
+              } else {
+                mediaUploadErrors.push(`Upload of "${localFilename}" returned unexpected payload`);
               }
+            } else {
+              const errText = await uploadRes.text().catch(() => "");
+              mediaUploadErrors.push(`Upload of "${localFilename}" failed: ${uploadRes.status} ${errText || uploadRes.statusText}`);
+            }
+          } catch (err: any) {
+            mediaUploadErrors.push(`Upload of "${localFilename}" threw: ${err?.message ?? "unknown"}`);
+          }
+          continue;
+        }
+
+        // ── Path 2: external URL via upload-from-url ──────────────────────
+        let absoluteUrl: string | null = null;
+        if (/^https?:\/\//i.test(mediaUrl)) {
+          absoluteUrl = mediaUrl;
+        } else if (mediaUrl.startsWith("/")) {
+          absoluteUrl = publicUrl ? `${publicUrl}${mediaUrl}` : null;
+        } else {
+          absoluteUrl = mediaUrl;
+        }
+        if (!absoluteUrl) {
+          mediaUploadErrors.push(`Cannot resolve media URL "${mediaUrl}" — publicUrl not configured`);
+          continue;
+        }
+        try {
+          const uploadRes = await fetch(this.url("/upload-from-url"), {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify({ url: absoluteUrl }),
+          });
+          if (uploadRes.ok) {
+            const uploadData = await uploadRes.json();
+            if (uploadData.id && uploadData.path) {
+              mediaItems.push({ id: uploadData.id, path: uploadData.path });
+            } else {
+              mediaUploadErrors.push(`Upload of "${absoluteUrl}" returned unexpected payload`);
             }
-          } catch {
-            // Skip failed uploads
+          } else {
+            const errText = await uploadRes.text().catch(() => "");
+            mediaUploadErrors.push(`Upload of "${absoluteUrl}" failed: ${uploadRes.status} ${errText || uploadRes.statusText}`);
           }
+        } catch (err: any) {
+          mediaUploadErrors.push(`Upload of "${absoluteUrl}" threw: ${err?.message ?? "unknown"}`);
         }
       }
 
-      // Build post payload per Postiz API
+      // If any media was requested but NONE uploaded successfully, fail the post
+      // rather than silently publishing text-only — user expected the image.
+      if (input.mediaUrls?.length && mediaItems.length === 0) {
+        return {
+          id: null,
+          status: "failed",
+          backendData: { error: "Media upload failed", details: mediaUploadErrors },
+        };
+      }
+
+      // Platform-specific default settings required by Postiz.
+      // These mirror the validation rules Postiz applies per integration:
+      //  - Instagram/Facebook: post_type ("post" | "story")
+      //  - X (Twitter): who_can_reply_post ("everyone" | "following" | "mentionedUsers" | "subscribers" | "verified")
+      const SETTINGS_DEFAULTS: Record<string, Record<string, unknown>> = {
+        instagram: { post_type: "post" },
+        facebook: { post_type: "post" },
+        x: { who_can_reply_post: "everyone" },
+      };
+
+      // Build post payload per Postiz API.
+      // Postiz treats `value` as a thread — a second entry becomes the
+      // first comment on IG/Facebook or a thread reply on X/Threads/LinkedIn.
+      const firstCommentText = input.firstComment?.trim();
+      const valueEntries: Array<{ content: string; image: Array<{ id: string; path: string }> }> = [
+        { content: input.text, image: mediaItems },
+      ];
+      if (firstCommentText) {
+        valueEntries.push({ content: firstCommentText, image: [] });
+      }
+
       const postEntries = matchedIntegrations.map((ig) => ({
         integration: { id: ig.id },
-        value: [{
-          content: input.text,
-          image: mediaItems,
-        }],
-        settings: { __type: ig.identifier },
+        value: valueEntries,
+        settings: {
+          __type: ig.identifier,
+          ...(SETTINGS_DEFAULTS[ig.identifier] ?? {}),
+        },
       }));
 
       const body: Record<string, unknown> = {
         type: input.scheduledAt ? "schedule" : "now",
         date: input.scheduledAt || new Date().toISOString(),
         shortLink: false,
+        tags: [],
         posts: postEntries,
       };
 

package/server/socialmedia/manager.ts

@@ -12,12 +12,47 @@ import type {
   SocialComment,
   SocialProfile,
   ListPostsOpts,
+  SocialPlatform,
 } from "./types.js";
 import * as store from "./store.js";
+import { BrowserAdapter } from "./adapters/browser-adapter.js";
 
 let cachedAdapter: SocialMediaAdapter | null = null;
 let cachedBackendKey: string | null = null;
 
+// Singleton BrowserAdapter — only one persistent Playwright session per platform,
+// so there's no per-config variation to cache.
+let browserAdapterSingleton: BrowserAdapter | null = null;
+
+function getBrowserAdapter(): BrowserAdapter {
+  if (!browserAdapterSingleton) browserAdapterSingleton = new BrowserAdapter();
+  return browserAdapterSingleton;
+}
+
+/** Platforms routed through the browser (rather than the primary backend). */
+function browserPlatformsFrom(settings: SocialMediaSettings): SocialPlatform[] {
+  return settings.browserPlatforms ?? [];
+}
+
+/**
+ * Coerce `platforms` input to a clean SocialPlatform[]. The Content Agent has
+ * occasionally sent `[{id, name}]` objects (from a Postiz integration listing)
+ * instead of plain strings, which corrupted drafts and crashed the UI.
+ */
+function coercePlatforms(input: unknown): SocialPlatform[] {
+  if (!Array.isArray(input)) return [];
+  const out: SocialPlatform[] = [];
+  for (const p of input) {
+    if (typeof p === "string" && p) { out.push(p as SocialPlatform); continue; }
+    if (p && typeof p === "object") {
+      const o = p as { name?: unknown; platform?: unknown };
+      if (typeof o.name === "string" && o.name) { out.push(o.name as SocialPlatform); continue; }
+      if (typeof o.platform === "string" && o.platform) { out.push(o.platform as SocialPlatform); continue; }
+    }
+  }
+  return out;
+}
+
 export async function getAdapter(settings?: SocialMediaSettings): Promise<SocialMediaAdapter> {
   const s = settings ?? store.getSettings();
   if (!s.backend) {
@@ -43,11 +78,6 @@ export async function getAdapter(settings?: SocialMediaSettings): Promise<Social
       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 });
@@ -80,6 +110,9 @@ export async function createPost(input: CreatePostInput): Promise<SocialPost> {
   const settings = store.getSettings();
   const now = new Date().toISOString();
 
+  // Defensive: agents have occasionally sent platforms as object arrays.
+  input = { ...input, platforms: coercePlatforms(input.platforms) };
+
   const post: SocialPost = {
     id: randomUUID(),
     text: input.text,
@@ -104,17 +137,115 @@ export async function createPost(input: CreatePostInput): Promise<SocialPost> {
     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 };
+  // ── Partition platforms between Browser and primary backend ────────────────
+  const browserSet = new Set(browserPlatformsFrom(settings));
+  const browserPlatforms = input.platforms.filter((p) => browserSet.has(p));
+  const primaryPlatforms = input.platforms.filter((p) => !browserSet.has(p));
+
+  type GroupResult = {
+    group: "browser" | "primary";
+    ok: boolean;
+    id: string | null;
+    status: string;
+    backendData?: unknown;
+    error?: string;
+  };
+  const groupResults: GroupResult[] = [];
+
+  // Primary backend group
+  if (primaryPlatforms.length > 0) {
+    try {
+      const adapter = await getAdapter(settings);
+      const result = await adapter.createPost({ ...input, platforms: primaryPlatforms });
+      const ok = result.status === "published" || result.status === "scheduled";
+      groupResults.push({
+        group: "primary",
+        ok,
+        id: result.id,
+        status: result.status,
+        backendData: result.backendData,
+      });
+    } catch (err: any) {
+      groupResults.push({
+        group: "primary",
+        ok: false,
+        id: null,
+        status: "failed",
+        error: err?.message ?? "primary backend failed",
+      });
+    }
+  }
+
+  // Browser group (X / TikTok)
+  if (browserPlatforms.length > 0) {
+    try {
+      const adapter = getBrowserAdapter();
+      adapter.setTargetPlatforms(browserPlatforms);
+      const result = await adapter.createPost({ ...input, platforms: browserPlatforms });
+      const ok = result.status === "published" || result.status === "partial";
+      groupResults.push({
+        group: "browser",
+        ok,
+        id: result.id,
+        status: result.status,
+        backendData: result.backendData,
+      });
+    } catch (err: any) {
+      groupResults.push({
+        group: "browser",
+        ok: false,
+        id: null,
+        status: "failed",
+        error: err?.message ?? "browser adapter failed",
+      });
+    }
   }
 
+  // ── Merge group results into a single SocialPost ───────────────────────────
+  const anyOk = groupResults.some((g) => g.ok);
+  const anyFail = groupResults.some((g) => !g.ok);
+  // A primary-group result of "partial" also indicates a mixed outcome.
+  const primaryGroupPartial = groupResults.find((g) => g.group === "primary")?.status === "partial";
+  const browserGroupPartial = groupResults.find((g) => g.group === "browser")?.status === "partial";
+
+  let finalStatus: SocialPost["status"];
+  if (groupResults.length === 0) {
+    finalStatus = "failed";
+  } else if (anyOk && (anyFail || primaryGroupPartial || browserGroupPartial)) {
+    finalStatus = "partial";
+  } else if (anyOk) {
+    // Could be "scheduled" if the primary group was scheduled and there was no browser group.
+    const only = groupResults[0];
+    finalStatus = (only?.status === "scheduled" ? "scheduled" : "published");
+  } else {
+    finalStatus = "failed";
+  }
+
+  // Build a structured backendPostId-ish payload in backendData; keep the flat
+  // string field for backwards-compat (first available ID).
+  const primaryRes = groupResults.find((g) => g.group === "primary");
+  const browserRes = groupResults.find((g) => g.group === "browser");
+  post.backendPostId = primaryRes?.id ?? browserRes?.id ?? null;
+  post.backendData = {
+    postiz: primaryRes
+      ? {
+          status: primaryRes.status,
+          id: primaryRes.id,
+          data: primaryRes.backendData,
+          error: primaryRes.error,
+        }
+      : undefined,
+    browser: browserRes
+      ? {
+          status: browserRes.status,
+          id: browserRes.id,
+          data: browserRes.backendData,
+          error: browserRes.error,
+        }
+      : undefined,
+  };
+  post.status = finalStatus;
+
   post.updatedAt = new Date().toISOString();
   store.savePost(post);
   return post;
@@ -128,6 +259,44 @@ export function getPost(id: string): SocialPost | null {
   return store.getPost(id);
 }
 
+/**
+ * Move an already-published or scheduled post back to draft state.
+ *
+ * Best-effort deletes the post from the configured backend (Postiz/Buffer)
+ * so it disappears from the platform queue / live feed, then resets the
+ * local record to status="draft" with no backend reference. The user can
+ * subsequently edit and re-publish via the normal draft flow.
+ *
+ * Note: this is destructive on the backend side — once the post is live on
+ * Instagram/LinkedIn/etc., deleting from Postiz removes it from those
+ * platforms (where the integration supports deletion). The local content
+ * (text, media, scheduledAt) is preserved.
+ */
+export async function moveToDraft(id: string): Promise<SocialPost> {
+  const post = store.getPost(id);
+  if (!post) throw new Error("Post not found");
+  if (post.status === "draft") return post;
+
+  // Best-effort backend delete — don't block the local downgrade if the
+  // backend has already cleaned up or the integration doesn't support it.
+  if (post.backendPostId) {
+    try {
+      const adapter = await getAdapter();
+      await adapter.deletePost(post.backendPostId);
+    } catch (err: any) {
+      console.error(`[socialmedia] moveToDraft: backend delete failed for ${post.backendPostId}:`, err?.message ?? err);
+    }
+  }
+
+  post.status = "draft";
+  post.backendId = null;
+  post.backendPostId = null;
+  post.backendData = undefined;
+  post.updatedAt = new Date().toISOString();
+  store.savePost(post);
+  return post;
+}
+
 export async function deletePost(id: string): Promise<boolean> {
   const post = store.getPost(id);
   if (!post) return false;
@@ -145,6 +314,35 @@ export async function deletePost(id: string): Promise<boolean> {
   return store.deleteLocalPost(id);
 }
 
+/**
+ * Archive or unarchive a post. Archiving hides the post from the default
+ * Queue view without removing it; `previousStatus` is preserved in
+ * `backendData._preArchiveStatus` so unarchiving restores the prior state.
+ */
+export async function setArchived(id: string, archived: boolean): Promise<SocialPost> {
+  const post = store.getPost(id);
+  if (!post) throw new Error("Post not found");
+
+  if (archived) {
+    if (post.status === "archived") return post;
+    const data = (post.backendData as Record<string, unknown> | undefined) ?? {};
+    post.backendData = { ...data, _preArchiveStatus: post.status };
+    post.status = "archived";
+  } else {
+    const data = (post.backendData as Record<string, unknown> | undefined) ?? {};
+    const prev = data._preArchiveStatus as SocialPost["status"] | undefined;
+    post.status = prev ?? "published";
+    if ("_preArchiveStatus" in data) {
+      const { _preArchiveStatus: _, ...rest } = data;
+      post.backendData = rest;
+    }
+  }
+
+  post.updatedAt = new Date().toISOString();
+  store.savePost(post);
+  return post;
+}
+
 export async function getPostAnalytics(id: string): Promise<PostAnalytics> {
   const post = store.getPost(id);
   if (!post?.backendPostId) {
@@ -177,10 +375,11 @@ export async function replyToComment(postId: string, commentId: string | null, t
 
 export async function createDraft(input: CreatePostInput & { createdBy?: "user" | "gemini" | "agent" }): Promise<SocialPost> {
   const now = new Date().toISOString();
+  const platforms = coercePlatforms(input.platforms);
   const post: SocialPost = {
     id: randomUUID(),
     text: input.text,
-    platforms: input.platforms,
+    platforms,
     scheduledAt: input.scheduledAt ?? null,
     mediaUrls: input.mediaUrls ?? [],
     status: "draft",
@@ -198,6 +397,26 @@ export async function createDraft(input: CreatePostInput & { createdBy?: "user"
   return post;
 }
 
+export async function updateDraft(id: string, updates: { text?: string; platforms?: string[]; scheduledAt?: 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");
+
+  if (updates.text !== undefined) post.text = updates.text;
+  if (updates.platforms !== undefined) post.platforms = coercePlatforms(updates.platforms);
+  if (updates.scheduledAt !== undefined) post.scheduledAt = updates.scheduledAt || null;
+  post.updatedAt = new Date().toISOString();
+  store.savePost(post);
+  return post;
+}
+
+export async function deleteDraft(id: string): Promise<boolean> {
+  const post = store.getPost(id);
+  if (!post) return false;
+  if (post.status !== "draft") throw new Error("Post is not a draft");
+  return store.deleteLocalPost(id);
+}
+
 export async function publishDraft(id: string): Promise<SocialPost> {
   const post = store.getPost(id);
   if (!post) throw new Error("Post not found");