posterboy 0.1.5

package/dist/index.js

@@ -0,0 +1,3645 @@
+#!/usr/bin/env node
+// @bun
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { parseArgs as parseArgs20 } from "util";
+
+// src/constants.ts
+var VERSION = "0.1.5";
+var CONFIG_DIR = `${process.env.HOME}/.posterboy`;
+var CONFIG_FILE = `${CONFIG_DIR}/config.json`;
+
+// src/commands/auth/login.ts
+import { parseArgs } from "node:util";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline";
+
+// src/constants.ts
+var CONFIG_DIR2 = `${process.env.HOME}/.posterboy`;
+var CONFIG_FILE2 = `${CONFIG_DIR2}/config.json`;
+var API_BASE_URL = "https://api.upload-post.com/api";
+var ALL_PLATFORMS = [
+  "tiktok",
+  "instagram",
+  "youtube",
+  "linkedin",
+  "facebook",
+  "x",
+  "threads",
+  "pinterest",
+  "reddit",
+  "bluesky"
+];
+var EXIT_CODES = {
+  SUCCESS: 0,
+  USER_ERROR: 1,
+  API_ERROR: 2,
+  NETWORK_ERROR: 3
+};
+
+// src/lib/errors.ts
+class PosterBoyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  json() {
+    return {
+      success: false,
+      error: this.message,
+      code: this.name.replace(/Error$/, "").toUpperCase()
+    };
+  }
+}
+
+class UserError extends PosterBoyError {
+  exitCode = EXIT_CODES.USER_ERROR;
+}
+
+class ApiError extends PosterBoyError {
+  exitCode = EXIT_CODES.API_ERROR;
+  statusCode;
+  apiMessage;
+  constructor(message, statusCode, apiMessage) {
+    super(message);
+    this.statusCode = statusCode;
+    this.apiMessage = apiMessage || message;
+  }
+  json() {
+    return {
+      success: false,
+      error: this.message,
+      code: "API_ERROR",
+      statusCode: this.statusCode,
+      apiMessage: this.apiMessage
+    };
+  }
+}
+
+class NetworkError extends PosterBoyError {
+  exitCode = EXIT_CODES.NETWORK_ERROR;
+}
+
+// src/lib/config.ts
+import { mkdirSync, readFileSync, existsSync } from "node:fs";
+import { writeFile, chmod } from "node:fs/promises";
+import { dirname } from "node:path";
+function readConfig() {
+  const configPath = resolveConfigPath();
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content);
+    validateConfig(config);
+    return config;
+  } catch (error) {
+    if (error instanceof UserError) {
+      throw error;
+    }
+    throw new UserError(`Failed to read config file at ${configPath}.
+` + `The file may be corrupted. Please run 'posterboy auth login' to recreate it.`);
+  }
+}
+async function writeConfig(config) {
+  const configPath = resolveConfigPath();
+  const configDir = dirname(configPath);
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+  }
+  validateConfig(config);
+  const content = JSON.stringify(config, null, 2);
+  await writeFile(configPath, content, { mode: 384 });
+  await chmod(configDir, 448);
+}
+function validateConfig(config) {
+  if (typeof config !== "object" || config === null) {
+    throw new UserError("Config must be an object");
+  }
+  if (typeof config.version !== "number") {
+    throw new UserError("Config must have a version number");
+  }
+  if (config.version !== 1) {
+    throw new UserError(`Unsupported config version: ${config.version}. Expected version 1.`);
+  }
+  if (config.api_key !== undefined && typeof config.api_key !== "string") {
+    throw new UserError("Config api_key must be a string");
+  }
+  if (config.default_profile !== undefined && typeof config.default_profile !== "string") {
+    throw new UserError("Config default_profile must be a string");
+  }
+  if (config.default_platforms !== undefined) {
+    if (!Array.isArray(config.default_platforms)) {
+      throw new UserError("Config default_platforms must be an array");
+    }
+  }
+  if (config.default_timezone !== undefined && typeof config.default_timezone !== "string") {
+    throw new UserError("Config default_timezone must be a string");
+  }
+}
+function resolveConfigPath(overridePath) {
+  return overridePath || process.env.POSTERBOY_CONFIG || CONFIG_FILE2;
+}
+function resolveValue(flagValue, envVar, configValue, defaultValue) {
+  if (flagValue !== undefined) {
+    return flagValue;
+  }
+  const envValue = process.env[envVar];
+  if (envValue !== undefined) {
+    return envValue;
+  }
+  if (configValue !== undefined) {
+    return configValue;
+  }
+  return defaultValue;
+}
+function getApiKey(flagValue, configValue) {
+  const apiKey = resolveValue(flagValue, "POSTERBOY_API_KEY", configValue, "");
+  if (!apiKey) {
+    throw new UserError(`API key not found.
+` + "Please run 'posterboy auth login' or set POSTERBOY_API_KEY environment variable.");
+  }
+  return apiKey;
+}
+function getDefaultProfile(flagValue, config) {
+  return resolveValue(flagValue, "POSTERBOY_PROFILE", config?.default_profile, undefined);
+}
+
+// src/lib/api.ts
+class ApiClient {
+  apiKey;
+  baseUrl;
+  verbose;
+  constructor(apiKey, options) {
+    this.apiKey = apiKey;
+    this.baseUrl = options?.baseUrl ?? API_BASE_URL;
+    this.verbose = options?.verbose ?? false;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    if (this.verbose) {
+      const headers = {
+        Authorization: `Bearer ${this.apiKey.substring(0, 7)}...`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      };
+      console.error(`[verbose] → ${method} ${url}`);
+      console.error(`[verbose]   Headers: ${JSON.stringify(headers)}`);
+    }
+    const startTime = Date.now();
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const elapsed = Date.now() - startTime;
+      if (this.verbose) {
+        console.error(`[verbose] ← ${response.status} ${response.statusText} (${elapsed}ms)`);
+      }
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage = `API error: ${response.status}`;
+        let apiMessage = errorMessage;
+        try {
+          const parsed = JSON.parse(errorBody);
+          errorMessage = parsed.message || parsed.error || errorMessage;
+          apiMessage = parsed.message || parsed.error || apiMessage;
+        } catch {}
+        throw new ApiError(errorMessage, response.status, apiMessage);
+      }
+      try {
+        return await response.json();
+      } catch {
+        throw new ApiError("Invalid JSON response from API", response.status, "Response body was not valid JSON");
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (this.verbose && error instanceof Error) {
+        console.error(`[verbose] ✗ ${error.message}`);
+      }
+      if (error instanceof ApiError)
+        throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Request timeout after 30 seconds");
+      }
+      throw new NetworkError(error instanceof Error ? error.message : "Network request failed");
+    }
+  }
+  async uploadRequest(method, path, formData) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 120000);
+    if (this.verbose) {
+      const headers = {
+        Authorization: `Bearer ${this.apiKey.substring(0, 7)}...`,
+        Accept: "application/json"
+      };
+      console.error(`[verbose] → ${method} ${url} (upload)`);
+      console.error(`[verbose]   Headers: ${JSON.stringify(headers)}`);
+    }
+    const startTime = Date.now();
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          Accept: "application/json"
+        },
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const elapsed = Date.now() - startTime;
+      if (this.verbose) {
+        console.error(`[verbose] ← ${response.status} ${response.statusText} (${elapsed}ms)`);
+      }
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage = `API error: ${response.status}`;
+        let apiMessage = errorMessage;
+        try {
+          const parsed = JSON.parse(errorBody);
+          errorMessage = parsed.message || parsed.error || errorMessage;
+          apiMessage = parsed.message || parsed.error || apiMessage;
+        } catch {}
+        throw new ApiError(errorMessage, response.status, apiMessage);
+      }
+      try {
+        return await response.json();
+      } catch {
+        throw new ApiError("Invalid JSON response from API", response.status, "Response body was not valid JSON");
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (this.verbose && error instanceof Error) {
+        console.error(`[verbose] ✗ ${error.message}`);
+      }
+      if (error instanceof ApiError)
+        throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Request timeout after 120 seconds");
+      }
+      throw new NetworkError(error instanceof Error ? error.message : "Network request failed");
+    }
+  }
+  async me() {
+    return this.request("GET", "/uploadposts/me");
+  }
+  async listUsers() {
+    return this.request("GET", "/uploadposts/users");
+  }
+  async createUser(username) {
+    return this.request("POST", "/uploadposts/users", { username });
+  }
+  async deleteUser(username) {
+    return this.request("DELETE", "/uploadposts/users", { username });
+  }
+  async generateJwt(username, options) {
+    const body = { username };
+    if (options?.platforms)
+      body.platforms = options.platforms;
+    if (options?.redirect)
+      body.redirect = options.redirect;
+    return this.request("POST", "/uploadposts/users/generate-jwt", body);
+  }
+  async getUserProfile(username) {
+    return this.request("GET", `/uploadposts/users/${username}`);
+  }
+  async facebookPages(username) {
+    return this.request("GET", `/uploadposts/facebook/pages?username=${username}`);
+  }
+  async linkedinPages(username) {
+    return this.request("GET", `/uploadposts/linkedin/pages?username=${username}`);
+  }
+  async pinterestBoards(username) {
+    return this.request("GET", `/uploadposts/pinterest/boards?username=${username}`);
+  }
+  async postText(params) {
+    const body = {
+      profile: params.profile,
+      platforms: params.platforms,
+      text: params.text
+    };
+    if (params.schedule)
+      body.schedule = params.schedule;
+    if (params.timezone)
+      body.timezone = params.timezone;
+    if (params.queue)
+      body.queue = params.queue;
+    if (params.async)
+      body.async = params.async;
+    if (params.first_comment)
+      body.first_comment = params.first_comment;
+    if (params.x_title)
+      body.x_title = params.x_title;
+    if (params.x_reply_to)
+      body.x_reply_to = params.x_reply_to;
+    if (params.x_reply_settings)
+      body.x_reply_settings = params.x_reply_settings;
+    if (params.x_quote_tweet)
+      body.x_quote_tweet = params.x_quote_tweet;
+    if (params.x_long_text_as_post !== undefined)
+      body.x_long_text_as_post = params.x_long_text_as_post;
+    if (params.x_poll_options)
+      body.x_poll_options = params.x_poll_options;
+    if (params.x_poll_duration)
+      body.x_poll_duration = params.x_poll_duration;
+    if (params.linkedin_title)
+      body.linkedin_title = params.linkedin_title;
+    if (params.linkedin_page)
+      body.linkedin_page = params.linkedin_page;
+    if (params.linkedin_visibility)
+      body.linkedin_visibility = params.linkedin_visibility;
+    if (params.facebook_title)
+      body.facebook_title = params.facebook_title;
+    if (params.facebook_page)
+      body.facebook_page = params.facebook_page;
+    if (params.facebook_link)
+      body.facebook_link = params.facebook_link;
+    if (params.threads_title)
+      body.threads_title = params.threads_title;
+    if (params.threads_long_text_as_post !== undefined)
+      body.threads_long_text_as_post = params.threads_long_text_as_post;
+    if (params.reddit_subreddit)
+      body.reddit_subreddit = params.reddit_subreddit;
+    if (params.reddit_flair)
+      body.reddit_flair = params.reddit_flair;
+    if (params.bluesky_title)
+      body.bluesky_title = params.bluesky_title;
+    if (params.bluesky_reply_to)
+      body.bluesky_reply_to = params.bluesky_reply_to;
+    return this.request("POST", "/upload_text", body);
+  }
+  async postPhotos(params) {
+    const formData = new FormData;
+    if (params.files) {
+      for (let i = 0;i < params.files.length; i++) {
+        const file = Bun.file(params.files[i]);
+        formData.append(`media_file_${i + 1}`, file);
+      }
+    } else if (params.urls) {
+      for (let i = 0;i < params.urls.length; i++) {
+        formData.append(`media_url_${i + 1}`, params.urls[i]);
+      }
+    }
+    formData.append("profile", params.profile);
+    formData.append("platforms", JSON.stringify(params.platforms));
+    formData.append("title", params.title);
+    if (params.description)
+      formData.append("description", params.description);
+    if (params.schedule)
+      formData.append("schedule", params.schedule);
+    if (params.timezone)
+      formData.append("timezone", params.timezone);
+    if (params.queue)
+      formData.append("queue", String(params.queue));
+    if (params.async)
+      formData.append("async", String(params.async));
+    if (params.first_comment)
+      formData.append("first_comment", params.first_comment);
+    if (params.instagram_title)
+      formData.append("instagram_title", params.instagram_title);
+    if (params.instagram_media_type)
+      formData.append("instagram_media_type", params.instagram_media_type);
+    if (params.instagram_collaborators)
+      formData.append("instagram_collaborators", params.instagram_collaborators);
+    if (params.instagram_location)
+      formData.append("instagram_location", params.instagram_location);
+    if (params.instagram_user_tags)
+      formData.append("instagram_user_tags", params.instagram_user_tags);
+    if (params.facebook_page)
+      formData.append("facebook_page", params.facebook_page);
+    if (params.facebook_media_type)
+      formData.append("facebook_media_type", params.facebook_media_type);
+    if (params.tiktok_title)
+      formData.append("tiktok_title", params.tiktok_title);
+    if (params.tiktok_privacy)
+      formData.append("tiktok_privacy", params.tiktok_privacy);
+    if (params.tiktok_disable_comments !== undefined)
+      formData.append("tiktok_disable_comments", String(params.tiktok_disable_comments));
+    if (params.tiktok_auto_music !== undefined)
+      formData.append("tiktok_auto_music", String(params.tiktok_auto_music));
+    if (params.tiktok_cover_index !== undefined)
+      formData.append("tiktok_cover_index", String(params.tiktok_cover_index));
+    if (params.x_title)
+      formData.append("x_title", params.x_title);
+    if (params.x_thread_image_layout)
+      formData.append("x_thread_image_layout", params.x_thread_image_layout);
+    if (params.linkedin_title)
+      formData.append("linkedin_title", params.linkedin_title);
+    if (params.linkedin_page)
+      formData.append("linkedin_page", params.linkedin_page);
+    if (params.linkedin_visibility)
+      formData.append("linkedin_visibility", params.linkedin_visibility);
+    if (params.threads_title)
+      formData.append("threads_title", params.threads_title);
+    if (params.pinterest_board)
+      formData.append("pinterest_board", params.pinterest_board);
+    if (params.pinterest_link)
+      formData.append("pinterest_link", params.pinterest_link);
+    if (params.pinterest_alt_text)
+      formData.append("pinterest_alt_text", params.pinterest_alt_text);
+    if (params.reddit_subreddit)
+      formData.append("reddit_subreddit", params.reddit_subreddit);
+    if (params.reddit_flair)
+      formData.append("reddit_flair", params.reddit_flair);
+    if (params.bluesky_title)
+      formData.append("bluesky_title", params.bluesky_title);
+    return this.uploadRequest("POST", "/upload_photos", formData);
+  }
+  async postVideo(params) {
+    const formData = new FormData;
+    if (params.file) {
+      formData.append("media_file", Bun.file(params.file));
+    } else if (params.url) {
+      formData.append("media_url", params.url);
+    }
+    formData.append("profile", params.profile);
+    formData.append("platforms", JSON.stringify(params.platforms));
+    formData.append("title", params.title);
+    if (params.description)
+      formData.append("description", params.description);
+    if (params.schedule)
+      formData.append("schedule", params.schedule);
+    if (params.timezone)
+      formData.append("timezone", params.timezone);
+    if (params.queue)
+      formData.append("queue", String(params.queue));
+    if (params.async)
+      formData.append("async", String(params.async));
+    if (params.first_comment)
+      formData.append("first_comment", params.first_comment);
+    if (params.tiktok_title)
+      formData.append("tiktok_title", params.tiktok_title);
+    if (params.tiktok_privacy)
+      formData.append("tiktok_privacy", params.tiktok_privacy);
+    if (params.tiktok_disable_duet !== undefined)
+      formData.append("tiktok_disable_duet", String(params.tiktok_disable_duet));
+    if (params.tiktok_disable_comment !== undefined)
+      formData.append("tiktok_disable_comment", String(params.tiktok_disable_comment));
+    if (params.tiktok_disable_stitch !== undefined)
+      formData.append("tiktok_disable_stitch", String(params.tiktok_disable_stitch));
+    if (params.tiktok_post_mode)
+      formData.append("tiktok_post_mode", params.tiktok_post_mode);
+    if (params.tiktok_cover_timestamp !== undefined)
+      formData.append("tiktok_cover_timestamp", String(params.tiktok_cover_timestamp));
+    if (params.tiktok_brand_content !== undefined)
+      formData.append("tiktok_brand_content", String(params.tiktok_brand_content));
+    if (params.tiktok_brand_organic !== undefined)
+      formData.append("tiktok_brand_organic", String(params.tiktok_brand_organic));
+    if (params.tiktok_aigc !== undefined)
+      formData.append("tiktok_aigc", String(params.tiktok_aigc));
+    if (params.instagram_title)
+      formData.append("instagram_title", params.instagram_title);
+    if (params.instagram_media_type)
+      formData.append("instagram_media_type", params.instagram_media_type);
+    if (params.instagram_collaborators)
+      formData.append("instagram_collaborators", params.instagram_collaborators);
+    if (params.instagram_cover_url)
+      formData.append("instagram_cover_url", params.instagram_cover_url);
+    if (params.instagram_share_to_feed !== undefined)
+      formData.append("instagram_share_to_feed", String(params.instagram_share_to_feed));
+    if (params.instagram_audio_name)
+      formData.append("instagram_audio_name", params.instagram_audio_name);
+    if (params.instagram_thumb_offset !== undefined)
+      formData.append("instagram_thumb_offset", String(params.instagram_thumb_offset));
+    if (params.youtube_title)
+      formData.append("youtube_title", params.youtube_title);
+    if (params.youtube_description)
+      formData.append("youtube_description", params.youtube_description);
+    if (params.youtube_tags)
+      formData.append("youtube_tags", params.youtube_tags);
+    if (params.youtube_category)
+      formData.append("youtube_category", params.youtube_category);
+    if (params.youtube_privacy)
+      formData.append("youtube_privacy", params.youtube_privacy);
+    if (params.youtube_embeddable !== undefined)
+      formData.append("youtube_embeddable", String(params.youtube_embeddable));
+    if (params.youtube_license)
+      formData.append("youtube_license", params.youtube_license);
+    if (params.youtube_kids !== undefined)
+      formData.append("youtube_kids", String(params.youtube_kids));
+    if (params.youtube_synthetic_media !== undefined)
+      formData.append("youtube_synthetic_media", String(params.youtube_synthetic_media));
+    if (params.youtube_language)
+      formData.append("youtube_language", params.youtube_language);
+    if (params.youtube_thumbnail)
+      formData.append("youtube_thumbnail", params.youtube_thumbnail);
+    if (params.youtube_recording_date)
+      formData.append("youtube_recording_date", params.youtube_recording_date);
+    if (params.linkedin_title)
+      formData.append("linkedin_title", params.linkedin_title);
+    if (params.linkedin_description)
+      formData.append("linkedin_description", params.linkedin_description);
+    if (params.linkedin_page)
+      formData.append("linkedin_page", params.linkedin_page);
+    if (params.linkedin_visibility)
+      formData.append("linkedin_visibility", params.linkedin_visibility);
+    if (params.facebook_title)
+      formData.append("facebook_title", params.facebook_title);
+    if (params.facebook_description)
+      formData.append("facebook_description", params.facebook_description);
+    if (params.facebook_page)
+      formData.append("facebook_page", params.facebook_page);
+    if (params.facebook_media_type)
+      formData.append("facebook_media_type", params.facebook_media_type);
+    if (params.facebook_thumbnail_url)
+      formData.append("facebook_thumbnail_url", params.facebook_thumbnail_url);
+    if (params.x_title)
+      formData.append("x_title", params.x_title);
+    if (params.x_reply_settings)
+      formData.append("x_reply_settings", params.x_reply_settings);
+    if (params.threads_title)
+      formData.append("threads_title", params.threads_title);
+    if (params.pinterest_title)
+      formData.append("pinterest_title", params.pinterest_title);
+    if (params.pinterest_description)
+      formData.append("pinterest_description", params.pinterest_description);
+    if (params.pinterest_board)
+      formData.append("pinterest_board", params.pinterest_board);
+    if (params.pinterest_link)
+      formData.append("pinterest_link", params.pinterest_link);
+    if (params.pinterest_alt_text)
+      formData.append("pinterest_alt_text", params.pinterest_alt_text);
+    if (params.reddit_title)
+      formData.append("reddit_title", params.reddit_title);
+    if (params.reddit_subreddit)
+      formData.append("reddit_subreddit", params.reddit_subreddit);
+    if (params.reddit_flair)
+      formData.append("reddit_flair", params.reddit_flair);
+    if (params.bluesky_title)
+      formData.append("bluesky_title", params.bluesky_title);
+    return this.uploadRequest("POST", "/upload_videos", formData);
+  }
+  async postDocument(params) {
+    const formData = new FormData;
+    if (params.file) {
+      const file = Bun.file(params.file);
+      formData.append("media_file", file);
+    } else if (params.url) {
+      formData.append("media_url", params.url);
+    }
+    formData.append("profile", params.profile);
+    formData.append("title", params.title);
+    if (params.description)
+      formData.append("description", params.description);
+    if (params.linkedin_page)
+      formData.append("linkedin_page", params.linkedin_page);
+    if (params.linkedin_visibility)
+      formData.append("linkedin_visibility", params.linkedin_visibility);
+    if (params.schedule)
+      formData.append("schedule", params.schedule);
+    if (params.timezone)
+      formData.append("timezone", params.timezone);
+    if (params.queue)
+      formData.append("queue", String(params.queue));
+    if (params.async)
+      formData.append("async", String(params.async));
+    return this.uploadRequest("POST", "/upload_document", formData);
+  }
+  async getStatus(id, type = "request_id") {
+    const queryParam = type === "job_id" ? `job_id=${id}` : `request_id=${id}`;
+    return this.request("GET", `/uploadposts/status?${queryParam}`);
+  }
+  async listScheduledPosts(profile) {
+    const queryParam = profile ? `?profile=${encodeURIComponent(profile)}` : "";
+    return this.request("GET", `/uploadposts/schedule${queryParam}`);
+  }
+  async cancelScheduledPost(jobId) {
+    return this.request("DELETE", `/uploadposts/schedule/${jobId}`);
+  }
+  async modifyScheduledPost(jobId, updates) {
+    return this.request("PATCH", `/uploadposts/schedule/${jobId}`, updates);
+  }
+  async getQueueSettings(profile) {
+    return this.request("GET", `/uploadposts/queue/settings?profile=${encodeURIComponent(profile)}`);
+  }
+  async updateQueueSettings(profile, updates) {
+    const body = { profile, ...updates };
+    return this.request("POST", "/uploadposts/queue/settings", body);
+  }
+  async previewQueue(profile, count) {
+    const queryParams = new URLSearchParams({ profile });
+    if (count !== undefined) {
+      queryParams.set("count", count.toString());
+    }
+    return this.request("GET", `/uploadposts/queue/preview?${queryParams}`);
+  }
+  async nextSlot(profile) {
+    return this.request("GET", `/uploadposts/queue/next-slot?profile=${encodeURIComponent(profile)}`);
+  }
+  async getHistory(profile, page, limit) {
+    const queryParams = new URLSearchParams;
+    if (profile)
+      queryParams.set("profile", profile);
+    if (page !== undefined)
+      queryParams.set("page", page.toString());
+    if (limit !== undefined)
+      queryParams.set("limit", limit.toString());
+    const queryString = queryParams.toString();
+    const path = queryString ? `/uploadposts/history?${queryString}` : "/uploadposts/history";
+    return this.request("GET", path);
+  }
+  async getAnalytics(profile, platforms, facebookPage, linkedinPage) {
+    const queryParams = new URLSearchParams;
+    if (platforms && platforms.length > 0)
+      queryParams.set("platforms", platforms.join(","));
+    if (facebookPage)
+      queryParams.set("facebook_page", facebookPage);
+    if (linkedinPage)
+      queryParams.set("linkedin_page", linkedinPage);
+    const queryString = queryParams.toString();
+    const path = queryString ? `/analytics/${encodeURIComponent(profile)}?${queryString}` : `/analytics/${encodeURIComponent(profile)}`;
+    return this.request("GET", path);
+  }
+}
+
+// src/lib/output.ts
+var ANSI = {
+  BOLD: "\x1B[1m",
+  CYAN: "\x1B[36m",
+  YELLOW: "\x1B[33m",
+  GREEN: "\x1B[32m",
+  RED: "\x1B[31m",
+  GRAY: "\x1B[90m",
+  RESET: "\x1B[0m"
+};
+
+class OutputFormatter {
+  _mode;
+  _colorEnabled;
+  constructor(forceMode, colorEnabled = true) {
+    if (forceMode) {
+      this._mode = forceMode;
+    } else if (!process.stdout.isTTY) {
+      this._mode = "json";
+    } else {
+      this._mode = "pretty";
+    }
+    this._colorEnabled = colorEnabled && !process.env.NO_COLOR;
+  }
+  mode() {
+    return this._mode;
+  }
+  json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+  pretty(lines) {
+    console.log(lines.join(`
+`));
+  }
+  error(message, details) {
+    const prefix = this.color("Error:", "RED");
+    console.error(`${prefix} ${message}`);
+    if (details) {
+      console.error(details);
+    }
+  }
+  usage(count, limit) {
+    const remaining = limit - count;
+    const line = `Usage: ${count} / ${limit} (${remaining} remaining)`;
+    if (this._mode === "json") {
+      return;
+    }
+    console.log(`
+` + line);
+  }
+  table(headers, rows) {
+    if (this._mode === "json") {
+      return;
+    }
+    const widths = headers.map((h, i) => {
+      const maxRowWidth = Math.max(...rows.map((r) => (r[i] || "").length));
+      return Math.max(h.length, maxRowWidth);
+    });
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+    console.log(this.color(headerLine, "CYAN"));
+    rows.forEach((row) => {
+      const rowLine = row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+      console.log(rowLine);
+    });
+  }
+  color(text, colorName) {
+    if (!this._colorEnabled) {
+      return text;
+    }
+    return `${ANSI[colorName]}${text}${ANSI.RESET}`;
+  }
+  header(text) {
+    return this.color(text, "CYAN");
+  }
+  label(text) {
+    return this.color(text, "BOLD");
+  }
+  success(text) {
+    return this.color(text, "GREEN");
+  }
+  warning(text) {
+    return this.color(text, "YELLOW");
+  }
+  muted(text) {
+    return this.color(text, "GRAY");
+  }
+}
+function createOutputFormatter(jsonFlag, prettyFlag, colorEnabled = true) {
+  let mode;
+  if (jsonFlag) {
+    mode = "json";
+  } else if (prettyFlag) {
+    mode = "pretty";
+  }
+  return new OutputFormatter(mode, colorEnabled);
+}
+
+// src/commands/auth/login.ts
+async function authLogin(args, globalFlags) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      key: { type: "string" }
+    },
+    strict: false
+  });
+  let apiKey = values.key;
+  if (!apiKey) {
+    if (stdin.isTTY) {
+      apiKey = await promptForKey();
+    } else {
+      throw new UserError(`API key required. Use --key flag or run interactively.
+Usage: posterboy auth login --key <your-api-key>`);
+    }
+  }
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const accountInfo = await client.me();
+  const existingConfig = readConfig();
+  const config = existingConfig || { version: 1 };
+  config.api_key = apiKey;
+  await writeConfig(config);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  const configPath = resolveConfigPath(globalFlags.config);
+  if (formatter.mode() === "json") {
+    formatter.json({
+      success: true,
+      email: accountInfo.email,
+      plan: accountInfo.plan,
+      message: `API key saved to ${configPath}`
+    });
+  } else {
+    formatter.pretty([
+      "API key validated and saved.",
+      `  ${formatter.label("Account:")} ${accountInfo.email}`,
+      `  ${formatter.label("Plan:")}    ${accountInfo.plan}`,
+      `  ${formatter.label("Config:")}  ${configPath}`
+    ]);
+  }
+}
+async function promptForKey() {
+  const rl = createInterface({
+    input: stdin,
+    output: stdout
+  });
+  return new Promise((resolve) => {
+    rl.question("Enter your Upload-Post API key: ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// src/commands/auth/status.ts
+async function authStatus(args, globalFlags) {
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const accountInfo = await client.me();
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({
+      email: accountInfo.email,
+      plan: accountInfo.plan,
+      usage: accountInfo.usage
+    });
+  } else {
+    const usage = accountInfo.usage;
+    formatter.pretty([
+      formatter.header("Account Status"),
+      `  ${formatter.label("Email:")}     ${accountInfo.email}`,
+      `  ${formatter.label("Plan:")}      ${accountInfo.plan}`,
+      `  ${formatter.label("Usage:")}     ${usage.count} / ${usage.limit} uploads this month (${usage.remaining} remaining)`
+    ]);
+  }
+}
+
+// src/commands/profiles/list.ts
+async function profilesList(args, globalFlags) {
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.listUsers();
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({
+      profiles: result.users,
+      count: result.users.length,
+      limit: 2
+    });
+  } else {
+    if (result.users.length === 0) {
+      formatter.pretty([
+        formatter.header("Profiles"),
+        "  No profiles found. Create one with: posterboy profiles create --username <name>"
+      ]);
+    } else {
+      const lines = [formatter.header("Profiles")];
+      for (const profile of result.users) {
+        const platformsDisplay = profile.connected_platforms.length > 0 ? profile.connected_platforms.join(", ") : formatter.muted("none");
+        const createdDate = new Date(profile.created_at).toLocaleDateString();
+        lines.push(`  ${formatter.label(profile.username)}`, `    Platforms: ${platformsDisplay}`, `    Created:   ${createdDate}`, "");
+      }
+      lines.push(formatter.muted(`${result.users.length} / 2 profiles`));
+      formatter.pretty(lines);
+    }
+  }
+}
+
+// src/commands/profiles/create.ts
+import { parseArgs as parseArgs2 } from "node:util";
+async function profilesCreate(args, globalFlags) {
+  const { values } = parseArgs2({
+    args,
+    options: {
+      username: { type: "string" }
+    },
+    strict: false
+  });
+  const username = values.username;
+  if (!username) {
+    throw new UserError(`Username is required.
+Usage: posterboy profiles create --username <name>`);
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.createUser(username);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({
+      success: result.success,
+      profile: result.profile
+    });
+  } else {
+    formatter.pretty([
+      formatter.success(`Profile '${username}' created successfully.`),
+      "",
+      "Next step: Connect social accounts with:",
+      `  posterboy profiles connect --username ${username}`
+    ]);
+  }
+}
+
+// src/commands/profiles/delete.ts
+import { parseArgs as parseArgs3 } from "node:util";
+import { stdin as stdin2, stdout as stdout2 } from "node:process";
+import { createInterface as createInterface2 } from "node:readline";
+async function profilesDelete(args, globalFlags) {
+  const { values } = parseArgs3({
+    args,
+    options: {
+      username: { type: "string" },
+      confirm: { type: "boolean" }
+    },
+    strict: false
+  });
+  const username = values.username;
+  const confirm = values.confirm;
+  if (!username) {
+    throw new UserError(`Username is required.
+Usage: posterboy profiles delete --username <name>`);
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  if (!confirm) {
+    if (globalFlags.json) {
+      throw new UserError(`Deletion requires confirmation.
+Add --confirm flag to delete without prompting.`);
+    }
+    if (stdin2.isTTY) {
+      const shouldDelete = await promptForConfirmation(username);
+      if (!shouldDelete) {
+        console.log("Deletion cancelled.");
+        process.exit(0);
+      }
+    } else {
+      throw new UserError(`Deletion requires confirmation.
+Add --confirm flag when running non-interactively.`);
+    }
+  }
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.deleteUser(username);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({
+      success: result.success
+    });
+  } else {
+    formatter.pretty([
+      formatter.success(`Profile '${username}' deleted successfully.`)
+    ]);
+  }
+}
+async function promptForConfirmation(username) {
+  const rl = createInterface2({
+    input: stdin2,
+    output: stdout2
+  });
+  return new Promise((resolve) => {
+    rl.question(`Delete profile '${username}'? This removes all connected accounts. [y/N] `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === "y" || normalized === "yes");
+    });
+  });
+}
+
+// src/commands/profiles/connect.ts
+import { parseArgs as parseArgs4 } from "node:util";
+
+// src/lib/platforms.ts
+var PLATFORM_CAPABILITIES = {
+  tiktok: { text: false, photo: true, video: true, document: false },
+  instagram: { text: false, photo: true, video: true, document: false },
+  youtube: { text: false, photo: false, video: true, document: false },
+  linkedin: { text: true, photo: true, video: true, document: true },
+  facebook: { text: true, photo: true, video: true, document: false },
+  x: { text: true, photo: true, video: true, document: false },
+  threads: { text: true, photo: true, video: true, document: false },
+  pinterest: { text: false, photo: true, video: true, document: false },
+  reddit: { text: true, photo: true, video: true, document: false },
+  bluesky: { text: true, photo: true, video: true, document: false }
+};
+function validatePlatforms(platforms) {
+  if (platforms.length === 0) {
+    throw new UserError(`At least one platform is required.
+` + `Valid platforms: ${ALL_PLATFORMS.join(", ")}`);
+  }
+  const invalid = platforms.filter((p) => !ALL_PLATFORMS.includes(p));
+  if (invalid.length > 0) {
+    throw new UserError(`Invalid platform names: ${invalid.join(", ")}.
+` + `Valid platforms: ${ALL_PLATFORMS.join(", ")}`);
+  }
+  return platforms;
+}
+function getPlatformsForContentType(type) {
+  return ALL_PLATFORMS.filter((platform) => PLATFORM_CAPABILITIES[platform][type]);
+}
+function validateContentTypeForPlatforms(contentType, platforms) {
+  const unsupported = platforms.filter((p) => !PLATFORM_CAPABILITIES[p][contentType]);
+  if (unsupported.length > 0) {
+    const supported = getPlatformsForContentType(contentType);
+    throw new UserError(`${unsupported.join(", ")} does not support ${contentType} posts.
+` + `Supported platforms for ${contentType}: ${supported.join(", ")}`);
+  }
+}
+function validatePlatformRequirements(platforms, params) {
+  for (const platform of platforms) {
+    switch (platform) {
+      case "facebook":
+        if (!params.facebook_page) {
+          throw new UserError(`Facebook requires --facebook-page flag.
+` + `Tip: Set a default in ~/.posterboy/config.json:
+` + `  "platform_defaults": { "facebook": { "page_id": "your-page-id" } }`);
+        }
+        break;
+      case "pinterest":
+        if (!params.pinterest_board) {
+          throw new UserError(`Pinterest requires --pinterest-board flag.
+` + `Tip: Set a default in ~/.posterboy/config.json:
+` + `  "platform_defaults": { "pinterest": { "board_id": "your-board-id" } }`);
+        }
+        break;
+      case "reddit":
+        if (!params.reddit_subreddit) {
+          throw new UserError(`Reddit requires --reddit-subreddit flag.
+` + `Tip: Set a default in ~/.posterboy/config.json:
+` + `  "platform_defaults": { "reddit": { "subreddit": "yoursubreddit" } }`);
+        }
+        break;
+    }
+  }
+}
+
+// src/commands/profiles/connect.ts
+async function profilesConnect(args, globalFlags) {
+  const { values } = parseArgs4({
+    args,
+    options: {
+      username: { type: "string" },
+      platforms: { type: "string" },
+      redirect: { type: "string" }
+    },
+    strict: false
+  });
+  const username = values.username;
+  const platformsStr = values.platforms;
+  const redirect = values.redirect;
+  if (!username) {
+    throw new UserError(`Username is required.
+Usage: posterboy profiles connect --username <name> [--platforms platform1,platform2] [--redirect <url>]`);
+  }
+  let platforms;
+  if (platformsStr) {
+    platforms = validatePlatforms(platformsStr.split(",").map((p) => p.trim()));
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.generateJwt(username, { platforms, redirect });
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({
+      success: result.success,
+      access_url: result.access_url,
+      expires_in: result.expires_in
+    });
+  } else {
+    formatter.pretty([
+      formatter.header("Connect Social Accounts"),
+      "",
+      "Visit this URL to connect accounts:",
+      `  ${formatter.success(result.access_url)}`,
+      "",
+      formatter.muted(`Link expires in ${result.expires_in}`)
+    ]);
+  }
+}
+
+// src/commands/platforms.ts
+import { parseArgs as parseArgs5 } from "node:util";
+async function platforms(args, globalFlags) {
+  const { values } = parseArgs5({
+    args,
+    options: {
+      profile: { type: "string" }
+    },
+    strict: false
+  });
+  const config = readConfig();
+  const profile = values.profile || getDefaultProfile(globalFlags.profile, config);
+  if (!profile) {
+    throw new UserError(`Profile is required.
+` + `Use --profile flag or set default_profile in config.
+` + "Usage: posterboy platforms --profile <username>");
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.getUserProfile(profile);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    const platformStatuses = ALL_PLATFORMS.map((platform) => ({
+      platform,
+      connected: result.user.connected_platforms.includes(platform)
+    }));
+    formatter.json({
+      profile: result.user.username,
+      platforms: platformStatuses
+    });
+  } else {
+    const lines = [
+      formatter.header(`Platforms for ${result.user.username}`),
+      ""
+    ];
+    for (const platform of ALL_PLATFORMS) {
+      const connected = result.user.connected_platforms.includes(platform);
+      const indicator = connected ? formatter.success("✓") : formatter.muted("-");
+      const platformName = platform.padEnd(10);
+      lines.push(`  ${indicator} ${platformName}`);
+    }
+    lines.push("");
+    lines.push(formatter.muted(`${result.user.connected_platforms.length} of ${ALL_PLATFORMS.length} platforms connected`));
+    formatter.pretty(lines);
+  }
+}
+async function platformsPages(subcommand, args, globalFlags) {
+  const { values } = parseArgs5({
+    args,
+    options: {
+      profile: { type: "string" }
+    },
+    strict: false
+  });
+  const config = readConfig();
+  const profile = values.profile || getDefaultProfile(globalFlags.profile, config);
+  if (!profile) {
+    throw new UserError(`Profile is required.
+` + `Use --profile flag or set default_profile in config.
+` + `Usage: posterboy platforms pages ${subcommand} --profile <username>`);
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  switch (subcommand) {
+    case "facebook":
+      {
+        const result = await client.facebookPages(profile);
+        if (formatter.mode() === "json") {
+          formatter.json({
+            profile,
+            platform: "facebook",
+            pages: result.pages
+          });
+        } else {
+          const lines = [
+            formatter.header(`Facebook Pages for ${profile}`),
+            ""
+          ];
+          if (result.pages.length === 0) {
+            lines.push("  No Facebook pages found.");
+          } else {
+            for (const page of result.pages) {
+              lines.push(`  ${formatter.label(page.name)}`, `    ID:       ${page.id}`, `    Category: ${page.category}`, "");
+            }
+          }
+          formatter.pretty(lines);
+        }
+      }
+      break;
+    case "linkedin":
+      {
+        const result = await client.linkedinPages(profile);
+        if (formatter.mode() === "json") {
+          formatter.json({
+            profile,
+            platform: "linkedin",
+            pages: result.pages
+          });
+        } else {
+          const lines = [
+            formatter.header(`LinkedIn Pages for ${profile}`),
+            ""
+          ];
+          if (result.pages.length === 0) {
+            lines.push("  No LinkedIn pages found.");
+          } else {
+            for (const page of result.pages) {
+              lines.push(`  ${formatter.label(page.name)}`, `    ID: ${page.id}`, "");
+            }
+          }
+          formatter.pretty(lines);
+        }
+      }
+      break;
+    case "pinterest":
+      {
+        const result = await client.pinterestBoards(profile);
+        if (formatter.mode() === "json") {
+          formatter.json({
+            profile,
+            platform: "pinterest",
+            boards: result.boards
+          });
+        } else {
+          const lines = [
+            formatter.header(`Pinterest Boards for ${profile}`),
+            ""
+          ];
+          if (result.boards.length === 0) {
+            lines.push("  No Pinterest boards found.");
+          } else {
+            for (const board of result.boards) {
+              lines.push(`  ${formatter.label(board.name)}`, `    ID: ${board.id}`, "");
+            }
+          }
+          formatter.pretty(lines);
+        }
+      }
+      break;
+    default:
+      throw new UserError(`Unknown platform: ${subcommand}
+` + "Available platforms: facebook, linkedin, pinterest");
+  }
+}
+
+// src/commands/post/text.ts
+import { parseArgs as parseArgs6 } from "node:util";
+
+// src/lib/validation.ts
+function validatePlatforms2(platforms2) {
+  try {
+    return validatePlatforms(platforms2);
+  } catch (_error) {
+    if (_error instanceof Error) {
+      throw new UserError(_error.message);
+    }
+    throw _error;
+  }
+}
+function validateISODate(date) {
+  try {
+    const parsed = new Date(date);
+    if (isNaN(parsed.getTime())) {
+      throw new UserError(`Invalid ISO-8601 date: ${date}`);
+    }
+    if (parsed.getTime() <= Date.now()) {
+      throw new UserError(`Schedule date must be in the future: ${date}`);
+    }
+    const maxDate = new Date;
+    maxDate.setDate(maxDate.getDate() + 365);
+    if (parsed.getTime() > maxDate.getTime()) {
+      throw new UserError(`Schedule date must be within 365 days from now: ${date}`);
+    }
+    return true;
+  } catch (_error) {
+    if (_error instanceof UserError) {
+      throw _error;
+    }
+    throw new UserError(`Invalid date format: ${date}`);
+  }
+}
+function validateTimezone(tz) {
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: tz });
+    return true;
+  } catch {
+    throw new UserError(`Invalid timezone: ${tz}.
+` + `Must be a valid IANA timezone name (e.g., "America/New_York").`);
+  }
+}
+function validateMutuallyExclusive(options, errorMessage) {
+  const provided = Object.entries(options).filter(([_, val]) => val);
+  if (provided.length === 0) {
+    throw new UserError(errorMessage || `Exactly one of the following must be provided: ${Object.keys(options).join(", ")}`);
+  }
+  if (provided.length > 1) {
+    throw new UserError(errorMessage || `Only one of the following can be provided: ${provided.map(([k]) => k).join(", ")}`);
+  }
+}
+
+// src/commands/post/text.ts
+async function postText(args, globalFlags) {
+  const { values } = parseArgs6({
+    args,
+    options: {
+      body: { type: "string" },
+      file: { type: "string" },
+      stdin: { type: "boolean", default: false },
+      platforms: { type: "string" },
+      profile: { type: "string" },
+      schedule: { type: "string" },
+      timezone: { type: "string" },
+      queue: { type: "boolean", default: false },
+      async: { type: "boolean", default: false },
+      "first-comment": { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      "x-title": { type: "string" },
+      "x-reply-to": { type: "string" },
+      "x-reply-settings": { type: "string" },
+      "x-quote-tweet": { type: "string" },
+      "x-long-text-as-post": { type: "boolean" },
+      "x-poll-options": { type: "string", multiple: true },
+      "x-poll-duration": { type: "string" },
+      "linkedin-title": { type: "string" },
+      "linkedin-page": { type: "string" },
+      "linkedin-visibility": { type: "string" },
+      "facebook-title": { type: "string" },
+      "facebook-page": { type: "string" },
+      "facebook-link": { type: "string" },
+      "threads-title": { type: "string" },
+      "threads-long-text-as-post": { type: "boolean" },
+      "reddit-subreddit": { type: "string" },
+      "reddit-flair": { type: "string" },
+      "bluesky-title": { type: "string" },
+      "bluesky-reply-to": { type: "string" }
+    },
+    strict: false
+  });
+  let text;
+  const hasBody = !!values.body;
+  const hasFile = !!values.file;
+  const hasStdin = values.stdin;
+  const inputModes = [hasBody, hasFile, hasStdin].filter(Boolean).length;
+  if (inputModes === 0) {
+    throw new UserError(`Text content required. Provide exactly one of:
+` + `  --body <text>    Text content inline
+` + `  --file <path>    Read text from file
+` + "  --stdin          Read text from stdin");
+  }
+  if (inputModes > 1) {
+    throw new UserError(`Only one text input method allowed.
+` + "Choose one of: --body, --file, or --stdin");
+  }
+  if (hasBody) {
+    text = values.body;
+  } else if (hasFile) {
+    const filePath = values.file;
+    try {
+      text = await Bun.file(filePath).text();
+    } catch (error) {
+      throw new UserError(`Failed to read file: ${filePath}
+` + `Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else {
+    try {
+      text = await Bun.stdin.text();
+    } catch (error) {
+      throw new UserError(`Failed to read from stdin
+` + `Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (!text || text.trim().length === 0) {
+    throw new UserError("Text content cannot be empty");
+  }
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'post')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  let platforms2;
+  if (values.platforms) {
+    const platformList = values.platforms.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    platforms2 = validatePlatforms2(platformList);
+  } else if (config?.default_platforms && config.default_platforms.length > 0) {
+    platforms2 = config.default_platforms;
+  } else {
+    throw new UserError(`Platforms required. Provide one of:
+` + `  --platforms <list>                         (comma-separated: x,linkedin,threads)
+` + `  POSTERBOY_PLATFORMS=<list>                 (environment variable)
+` + '  "default_platforms": [...]                 (in ~/.posterboy/config.json)');
+  }
+  validateContentTypeForPlatforms("text", platforms2);
+  const params = {
+    profile,
+    platforms: platforms2,
+    text,
+    facebook_page: values["facebook-page"] || config?.platform_defaults?.facebook?.page_id,
+    reddit_subreddit: values["reddit-subreddit"] || config?.platform_defaults?.reddit?.subreddit
+  };
+  validatePlatformRequirements(platforms2, params);
+  if (values.schedule && values.queue) {
+    throw new UserError(`--schedule and --queue are mutually exclusive.
+` + "Use --schedule for a specific date/time, or --queue to use the next available slot.");
+  }
+  if (values.schedule) {
+    validateISODate(values.schedule);
+  }
+  if (values.timezone) {
+    validateTimezone(values.timezone);
+  }
+  const postParams = {
+    profile,
+    platforms: platforms2,
+    text
+  };
+  if (values.schedule)
+    postParams.schedule = values.schedule;
+  if (values.timezone)
+    postParams.timezone = values.timezone;
+  if (values.queue)
+    postParams.queue = values.queue;
+  if (values.async)
+    postParams.async = values.async;
+  if (values["first-comment"])
+    postParams.first_comment = values["first-comment"];
+  if (values["x-title"])
+    postParams.x_title = values["x-title"];
+  if (values["x-reply-to"])
+    postParams.x_reply_to = values["x-reply-to"];
+  if (values["x-reply-settings"])
+    postParams.x_reply_settings = values["x-reply-settings"];
+  if (values["x-quote-tweet"])
+    postParams.x_quote_tweet = values["x-quote-tweet"];
+  if (values["x-long-text-as-post"] !== undefined)
+    postParams.x_long_text_as_post = values["x-long-text-as-post"];
+  if (values["x-poll-options"]) {
+    const options = values["x-poll-options"].flatMap((opt) => opt.split(",")).map((o) => o.trim()).filter((o) => o.length > 0);
+    if (options.length < 2 || options.length > 4) {
+      throw new UserError(`X polls require 2-4 options. You provided ${options.length}.`);
+    }
+    postParams.x_poll_options = options;
+  }
+  if (values["x-poll-duration"]) {
+    const duration = parseInt(values["x-poll-duration"], 10);
+    if (isNaN(duration) || duration < 5 || duration > 10080) {
+      throw new UserError("Invalid poll duration. Must be a number between 5 and 10080 minutes (5 minutes to 7 days).");
+    }
+    postParams.x_poll_duration = duration;
+  }
+  if (values["linkedin-title"])
+    postParams.linkedin_title = values["linkedin-title"];
+  if (values["linkedin-page"])
+    postParams.linkedin_page = values["linkedin-page"];
+  if (values["linkedin-visibility"])
+    postParams.linkedin_visibility = values["linkedin-visibility"];
+  if (values["facebook-title"])
+    postParams.facebook_title = values["facebook-title"];
+  if (values["facebook-page"])
+    postParams.facebook_page = values["facebook-page"];
+  if (values["facebook-link"])
+    postParams.facebook_link = values["facebook-link"];
+  if (values["threads-title"])
+    postParams.threads_title = values["threads-title"];
+  if (values["threads-long-text-as-post"] !== undefined)
+    postParams.threads_long_text_as_post = values["threads-long-text-as-post"];
+  if (values["reddit-subreddit"])
+    postParams.reddit_subreddit = values["reddit-subreddit"];
+  if (values["reddit-flair"])
+    postParams.reddit_flair = values["reddit-flair"];
+  if (values["bluesky-title"])
+    postParams.bluesky_title = values["bluesky-title"];
+  if (values["bluesky-reply-to"])
+    postParams.bluesky_reply_to = values["bluesky-reply-to"];
+  if (values["dry-run"]) {
+    const formatter2 = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+    if (formatter2.mode() === "json") {
+      formatter2.json({
+        dry_run: true,
+        payload: postParams
+      });
+    } else {
+      formatter2.pretty([
+        formatter2.header("Dry Run - Request Payload:"),
+        "",
+        JSON.stringify(postParams, null, 2)
+      ]);
+    }
+    return;
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.postText(postParams);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    if (result.scheduled) {
+      formatter.pretty([
+        formatter.success("Post scheduled successfully!"),
+        `  ${formatter.label("Job ID:")}        ${result.job_id}`,
+        `  ${formatter.label("Scheduled for:")} ${result.scheduled_date}`
+      ]);
+    } else if (result.results) {
+      const successCount = Object.values(result.results).filter((r) => r.success).length;
+      const lines = [
+        formatter.success(`Posted to ${successCount} platform${successCount === 1 ? "" : "s"}:`),
+        ""
+      ];
+      for (const [platform, platformResult] of Object.entries(result.results)) {
+        if (platformResult.success && platformResult.url) {
+          lines.push(`  ${platform.padEnd(12)} ${platformResult.url}`);
+        } else if (!platformResult.success && platformResult.error) {
+          lines.push(`  ${platform.padEnd(12)} ${formatter.color("FAILED", "RED")} - ${platformResult.error}`);
+        }
+      }
+      if (result.usage) {
+        lines.push("");
+        lines.push(`Usage: ${result.usage.count} / ${result.usage.limit} (${result.usage.remaining} remaining)`);
+      }
+      formatter.pretty(lines);
+    } else {
+      formatter.pretty([
+        formatter.success("Post queued successfully!"),
+        `  ${formatter.label("Request ID:")} ${result.request_id || "N/A"}`
+      ]);
+    }
+  }
+}
+
+// src/commands/post/photo.ts
+import { parseArgs as parseArgs7 } from "node:util";
+async function validatePhotoFiles(files) {
+  const validExts = [".jpg", ".jpeg", ".png", ".gif"];
+  const maxSize = 8 * 1024 * 1024;
+  for (const filePath of files) {
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      throw new UserError(`File not found: ${filePath}`);
+    }
+    if (file.size > maxSize) {
+      throw new UserError(`File exceeds 8MB limit: ${filePath} (${(file.size / (1024 * 1024)).toFixed(1)}MB)`);
+    }
+    const ext = filePath.toLowerCase().match(/\.([^./\\]+)$/)?.[1];
+    if (!ext || !validExts.includes(`.${ext}`)) {
+      throw new UserError(`Unsupported format: ${filePath}. Supported: JPEG, PNG, GIF`);
+    }
+  }
+}
+async function postPhoto(args, globalFlags) {
+  const { values } = parseArgs7({
+    args,
+    options: {
+      files: { type: "string" },
+      urls: { type: "string" },
+      title: { type: "string" },
+      description: { type: "string" },
+      platforms: { type: "string" },
+      profile: { type: "string" },
+      schedule: { type: "string" },
+      timezone: { type: "string" },
+      queue: { type: "boolean", default: false },
+      async: { type: "boolean", default: false },
+      "first-comment": { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      "instagram-title": { type: "string" },
+      "instagram-media-type": { type: "string" },
+      "instagram-collaborators": { type: "string" },
+      "instagram-location": { type: "string" },
+      "instagram-user-tags": { type: "string" },
+      "facebook-page": { type: "string" },
+      "facebook-media-type": { type: "string" },
+      "tiktok-title": { type: "string" },
+      "tiktok-privacy": { type: "string" },
+      "tiktok-disable-comments": { type: "boolean" },
+      "tiktok-auto-music": { type: "boolean" },
+      "tiktok-cover-index": { type: "string" },
+      "x-title": { type: "string" },
+      "x-thread-image-layout": { type: "string" },
+      "linkedin-title": { type: "string" },
+      "linkedin-page": { type: "string" },
+      "linkedin-visibility": { type: "string" },
+      "threads-title": { type: "string" },
+      "pinterest-board": { type: "string" },
+      "pinterest-link": { type: "string" },
+      "pinterest-alt-text": { type: "string" },
+      "reddit-subreddit": { type: "string" },
+      "reddit-flair": { type: "string" },
+      "bluesky-title": { type: "string" }
+    },
+    strict: false
+  });
+  validateMutuallyExclusive({
+    "--files": !!values.files,
+    "--urls": !!values.urls
+  }, "Must provide either --files or --urls (not both)");
+  if (!values.title) {
+    throw new UserError("--title is required for photo posts");
+  }
+  let files;
+  let urls;
+  if (values.files) {
+    files = values.files.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+    await validatePhotoFiles(files);
+  } else if (values.urls) {
+    urls = values.urls.split(",").map((u) => u.trim()).filter((u) => u.length > 0);
+  }
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'post')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  let platforms2;
+  if (values.platforms) {
+    const platformList = values.platforms.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    platforms2 = validatePlatforms2(platformList);
+  } else if (config?.default_platforms && config.default_platforms.length > 0) {
+    platforms2 = config.default_platforms;
+  } else {
+    throw new UserError(`Platforms required. Provide one of:
+` + `  --platforms <list>                         (comma-separated: instagram,tiktok,facebook)
+` + `  POSTERBOY_PLATFORMS=<list>                 (environment variable)
+` + '  "default_platforms": [...]                 (in ~/.posterboy/config.json)');
+  }
+  validateContentTypeForPlatforms("photo", platforms2);
+  const params = {
+    profile,
+    platforms: platforms2,
+    facebook_page: values["facebook-page"] || config?.platform_defaults?.facebook?.page_id,
+    pinterest_board: values["pinterest-board"] || config?.platform_defaults?.pinterest?.board_id,
+    reddit_subreddit: values["reddit-subreddit"] || config?.platform_defaults?.reddit?.subreddit
+  };
+  validatePlatformRequirements(platforms2, params);
+  if (values.schedule && values.queue) {
+    throw new UserError(`--schedule and --queue are mutually exclusive.
+` + "Use --schedule for a specific date/time, or --queue to use the next available slot.");
+  }
+  if (values.schedule) {
+    validateISODate(values.schedule);
+  }
+  if (values.timezone) {
+    validateTimezone(values.timezone);
+  }
+  const postParams = {
+    profile,
+    platforms: platforms2,
+    files,
+    urls,
+    title: values.title
+  };
+  if (values.description)
+    postParams.description = values.description;
+  if (values.schedule)
+    postParams.schedule = values.schedule;
+  if (values.timezone)
+    postParams.timezone = values.timezone;
+  if (values.queue)
+    postParams.queue = values.queue;
+  if (values.async)
+    postParams.async = values.async;
+  if (values["first-comment"])
+    postParams.first_comment = values["first-comment"];
+  if (values["instagram-title"])
+    postParams.instagram_title = values["instagram-title"];
+  if (values["instagram-media-type"])
+    postParams.instagram_media_type = values["instagram-media-type"];
+  if (values["instagram-collaborators"])
+    postParams.instagram_collaborators = values["instagram-collaborators"];
+  if (values["instagram-location"])
+    postParams.instagram_location = values["instagram-location"];
+  if (values["instagram-user-tags"])
+    postParams.instagram_user_tags = values["instagram-user-tags"];
+  if (values["facebook-page"])
+    postParams.facebook_page = values["facebook-page"];
+  if (values["facebook-media-type"])
+    postParams.facebook_media_type = values["facebook-media-type"];
+  if (values["tiktok-title"])
+    postParams.tiktok_title = values["tiktok-title"];
+  if (values["tiktok-privacy"])
+    postParams.tiktok_privacy = values["tiktok-privacy"];
+  if (values["tiktok-disable-comments"] !== undefined)
+    postParams.tiktok_disable_comments = values["tiktok-disable-comments"];
+  if (values["tiktok-auto-music"] !== undefined)
+    postParams.tiktok_auto_music = values["tiktok-auto-music"];
+  if (values["tiktok-cover-index"]) {
+    const coverIndex = parseInt(values["tiktok-cover-index"], 10);
+    if (!isNaN(coverIndex)) {
+      postParams.tiktok_cover_index = coverIndex;
+    }
+  }
+  if (values["x-title"])
+    postParams.x_title = values["x-title"];
+  if (values["x-thread-image-layout"])
+    postParams.x_thread_image_layout = values["x-thread-image-layout"];
+  if (values["linkedin-title"])
+    postParams.linkedin_title = values["linkedin-title"];
+  if (values["linkedin-page"])
+    postParams.linkedin_page = values["linkedin-page"];
+  if (values["linkedin-visibility"])
+    postParams.linkedin_visibility = values["linkedin-visibility"];
+  if (values["threads-title"])
+    postParams.threads_title = values["threads-title"];
+  if (values["pinterest-board"])
+    postParams.pinterest_board = values["pinterest-board"];
+  if (values["pinterest-link"])
+    postParams.pinterest_link = values["pinterest-link"];
+  if (values["pinterest-alt-text"])
+    postParams.pinterest_alt_text = values["pinterest-alt-text"];
+  if (values["reddit-subreddit"])
+    postParams.reddit_subreddit = values["reddit-subreddit"];
+  if (values["reddit-flair"])
+    postParams.reddit_flair = values["reddit-flair"];
+  if (values["bluesky-title"])
+    postParams.bluesky_title = values["bluesky-title"];
+  if (values["dry-run"]) {
+    const formatter2 = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+    if (formatter2.mode() === "json") {
+      formatter2.json({
+        dry_run: true,
+        payload: postParams
+      });
+    } else {
+      formatter2.pretty([
+        formatter2.header("Dry Run - Request Payload:"),
+        "",
+        JSON.stringify(postParams, null, 2)
+      ]);
+    }
+    return;
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.postPhotos(postParams);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    if (result.scheduled) {
+      formatter.pretty([
+        formatter.success("Photo post scheduled successfully!"),
+        `  ${formatter.label("Job ID:")}        ${result.job_id}`,
+        `  ${formatter.label("Scheduled for:")} ${result.scheduled_date}`
+      ]);
+    } else if (result.results) {
+      const successCount = Object.values(result.results).filter((r) => r.success).length;
+      const lines = [
+        formatter.success(`Posted photos to ${successCount} platform${successCount === 1 ? "" : "s"}:`),
+        ""
+      ];
+      for (const [platform, platformResult] of Object.entries(result.results)) {
+        if (platformResult.success && platformResult.url) {
+          lines.push(`  ${platform.padEnd(12)} ${platformResult.url}`);
+        } else if (!platformResult.success && platformResult.error) {
+          lines.push(`  ${platform.padEnd(12)} ${formatter.color("FAILED", "RED")} - ${platformResult.error}`);
+        }
+      }
+      if (result.usage) {
+        lines.push("");
+        lines.push(`Usage: ${result.usage.count} / ${result.usage.limit} (${result.usage.remaining} remaining)`);
+      }
+      formatter.pretty(lines);
+    } else {
+      formatter.pretty([
+        formatter.success("Photo post queued successfully!"),
+        `  ${formatter.label("Request ID:")} ${result.request_id || "N/A"}`
+      ]);
+    }
+  }
+}
+
+// src/commands/post/video.ts
+import { parseArgs as parseArgs8 } from "node:util";
+async function validateVideoFile(filePath) {
+  const validExts = [".mp4", ".mov", ".webm", ".avi"];
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new UserError(`File not found: ${filePath}`);
+  }
+  const ext = filePath.toLowerCase().match(/\.([^./\\]+)$/)?.[1];
+  if (!ext || !validExts.includes(`.${ext}`)) {
+    throw new UserError(`Unsupported video format: ${filePath}. Supported: MP4, MOV, WebM, AVI`);
+  }
+  return { size: file.size };
+}
+async function postVideo(args, globalFlags) {
+  const { values } = parseArgs8({
+    args,
+    options: {
+      file: { type: "string" },
+      url: { type: "string" },
+      title: { type: "string" },
+      description: { type: "string" },
+      platforms: { type: "string" },
+      profile: { type: "string" },
+      schedule: { type: "string" },
+      timezone: { type: "string" },
+      queue: { type: "boolean", default: false },
+      async: { type: "boolean" },
+      "first-comment": { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      "tiktok-title": { type: "string" },
+      "tiktok-privacy": { type: "string" },
+      "tiktok-disable-duet": { type: "boolean" },
+      "tiktok-disable-comment": { type: "boolean" },
+      "tiktok-disable-stitch": { type: "boolean" },
+      "tiktok-post-mode": { type: "string" },
+      "tiktok-cover-timestamp": { type: "string" },
+      "tiktok-brand-content": { type: "boolean" },
+      "tiktok-brand-organic": { type: "boolean" },
+      "tiktok-aigc": { type: "boolean" },
+      "instagram-title": { type: "string" },
+      "instagram-media-type": { type: "string" },
+      "instagram-collaborators": { type: "string" },
+      "instagram-cover-url": { type: "string" },
+      "instagram-share-to-feed": { type: "boolean" },
+      "instagram-audio-name": { type: "string" },
+      "instagram-thumb-offset": { type: "string" },
+      "youtube-title": { type: "string" },
+      "youtube-description": { type: "string" },
+      "youtube-tags": { type: "string" },
+      "youtube-category": { type: "string" },
+      "youtube-privacy": { type: "string" },
+      "youtube-embeddable": { type: "boolean" },
+      "youtube-license": { type: "string" },
+      "youtube-kids": { type: "boolean" },
+      "youtube-synthetic-media": { type: "boolean" },
+      "youtube-language": { type: "string" },
+      "youtube-thumbnail": { type: "string" },
+      "youtube-recording-date": { type: "string" },
+      "linkedin-title": { type: "string" },
+      "linkedin-description": { type: "string" },
+      "linkedin-page": { type: "string" },
+      "linkedin-visibility": { type: "string" },
+      "facebook-title": { type: "string" },
+      "facebook-description": { type: "string" },
+      "facebook-page": { type: "string" },
+      "facebook-media-type": { type: "string" },
+      "facebook-thumbnail-url": { type: "string" },
+      "x-title": { type: "string" },
+      "x-reply-settings": { type: "string" },
+      "threads-title": { type: "string" },
+      "pinterest-title": { type: "string" },
+      "pinterest-description": { type: "string" },
+      "pinterest-board": { type: "string" },
+      "pinterest-link": { type: "string" },
+      "pinterest-alt-text": { type: "string" },
+      "reddit-title": { type: "string" },
+      "reddit-subreddit": { type: "string" },
+      "reddit-flair": { type: "string" },
+      "bluesky-title": { type: "string" }
+    },
+    strict: false
+  });
+  validateMutuallyExclusive({
+    "--file": !!values.file,
+    "--url": !!values.url
+  }, `Video source required. Provide exactly one of:
+` + `  --file <path>    Local video file
+` + "  --url <url>      Public video URL");
+  if (!values.title) {
+    throw new UserError("Title required. Use --title <text>");
+  }
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'post')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  let platforms2;
+  if (values.platforms) {
+    const platformList = values.platforms.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    platforms2 = validatePlatforms2(platformList);
+  } else if (config?.default_platforms && config.default_platforms.length > 0) {
+    platforms2 = config.default_platforms;
+  } else {
+    throw new UserError(`Platforms required. Provide one of:
+` + `  --platforms <list>                         (comma-separated: tiktok,youtube,instagram)
+` + `  POSTERBOY_PLATFORMS=<list>                 (environment variable)
+` + '  "default_platforms": [...]                 (in ~/.posterboy/config.json)');
+  }
+  validateContentTypeForPlatforms("video", platforms2);
+  let fileSize = 0;
+  if (values.file) {
+    const validation = await validateVideoFile(values.file);
+    fileSize = validation.size;
+  }
+  let shouldUseAsync = values.async;
+  if (fileSize > 50 * 1024 * 1024 && shouldUseAsync === undefined) {
+    shouldUseAsync = true;
+  }
+  const params = {
+    profile,
+    platforms: platforms2,
+    facebook_page: values["facebook-page"] || config?.platform_defaults?.facebook?.page_id,
+    pinterest_board: values["pinterest-board"] || config?.platform_defaults?.pinterest?.board_id,
+    reddit_subreddit: values["reddit-subreddit"] || config?.platform_defaults?.reddit?.subreddit
+  };
+  validatePlatformRequirements(platforms2, params);
+  if (values.schedule && values.queue) {
+    throw new UserError(`--schedule and --queue are mutually exclusive.
+` + "Use --schedule for a specific date/time, or --queue to use the next available slot.");
+  }
+  if (values.schedule) {
+    validateISODate(values.schedule);
+  }
+  if (values.timezone) {
+    validateTimezone(values.timezone);
+  }
+  const postParams = {
+    profile,
+    platforms: platforms2,
+    title: values.title
+  };
+  if (values.file)
+    postParams.file = values.file;
+  if (values.url)
+    postParams.url = values.url;
+  if (values.description)
+    postParams.description = values.description;
+  if (values.schedule)
+    postParams.schedule = values.schedule;
+  if (values.timezone)
+    postParams.timezone = values.timezone;
+  if (values.queue)
+    postParams.queue = values.queue;
+  if (shouldUseAsync !== undefined)
+    postParams.async = shouldUseAsync;
+  if (values["first-comment"])
+    postParams.first_comment = values["first-comment"];
+  if (values["tiktok-title"])
+    postParams.tiktok_title = values["tiktok-title"];
+  if (values["tiktok-privacy"])
+    postParams.tiktok_privacy = values["tiktok-privacy"] || config?.platform_defaults?.tiktok?.privacy;
+  if (values["tiktok-disable-duet"] !== undefined)
+    postParams.tiktok_disable_duet = values["tiktok-disable-duet"];
+  if (values["tiktok-disable-comment"] !== undefined)
+    postParams.tiktok_disable_comment = values["tiktok-disable-comment"];
+  if (values["tiktok-disable-stitch"] !== undefined)
+    postParams.tiktok_disable_stitch = values["tiktok-disable-stitch"];
+  if (values["tiktok-post-mode"])
+    postParams.tiktok_post_mode = values["tiktok-post-mode"];
+  if (values["tiktok-cover-timestamp"]) {
+    const timestamp = parseFloat(values["tiktok-cover-timestamp"]);
+    if (!isNaN(timestamp)) {
+      postParams.tiktok_cover_timestamp = timestamp;
+    }
+  }
+  if (values["tiktok-brand-content"] !== undefined)
+    postParams.tiktok_brand_content = values["tiktok-brand-content"];
+  if (values["tiktok-brand-organic"] !== undefined)
+    postParams.tiktok_brand_organic = values["tiktok-brand-organic"];
+  if (values["tiktok-aigc"] !== undefined)
+    postParams.tiktok_aigc = values["tiktok-aigc"];
+  if (values["instagram-title"])
+    postParams.instagram_title = values["instagram-title"];
+  if (values["instagram-media-type"])
+    postParams.instagram_media_type = values["instagram-media-type"];
+  if (values["instagram-collaborators"])
+    postParams.instagram_collaborators = values["instagram-collaborators"];
+  if (values["instagram-cover-url"])
+    postParams.instagram_cover_url = values["instagram-cover-url"];
+  if (values["instagram-share-to-feed"] !== undefined)
+    postParams.instagram_share_to_feed = values["instagram-share-to-feed"];
+  if (values["instagram-audio-name"])
+    postParams.instagram_audio_name = values["instagram-audio-name"];
+  if (values["instagram-thumb-offset"]) {
+    const offset = parseFloat(values["instagram-thumb-offset"]);
+    if (!isNaN(offset)) {
+      postParams.instagram_thumb_offset = offset;
+    }
+  }
+  if (values["youtube-title"])
+    postParams.youtube_title = values["youtube-title"];
+  if (values["youtube-description"])
+    postParams.youtube_description = values["youtube-description"];
+  if (values["youtube-tags"])
+    postParams.youtube_tags = values["youtube-tags"];
+  if (values["youtube-category"])
+    postParams.youtube_category = values["youtube-category"] || config?.platform_defaults?.youtube?.category;
+  if (values["youtube-privacy"])
+    postParams.youtube_privacy = values["youtube-privacy"] || config?.platform_defaults?.youtube?.privacy;
+  if (values["youtube-embeddable"] !== undefined)
+    postParams.youtube_embeddable = values["youtube-embeddable"];
+  if (values["youtube-license"])
+    postParams.youtube_license = values["youtube-license"];
+  if (values["youtube-kids"] !== undefined)
+    postParams.youtube_kids = values["youtube-kids"];
+  if (values["youtube-synthetic-media"] !== undefined)
+    postParams.youtube_synthetic_media = values["youtube-synthetic-media"];
+  if (values["youtube-language"])
+    postParams.youtube_language = values["youtube-language"];
+  if (values["youtube-thumbnail"])
+    postParams.youtube_thumbnail = values["youtube-thumbnail"];
+  if (values["youtube-recording-date"])
+    postParams.youtube_recording_date = values["youtube-recording-date"];
+  if (values["linkedin-title"])
+    postParams.linkedin_title = values["linkedin-title"];
+  if (values["linkedin-description"])
+    postParams.linkedin_description = values["linkedin-description"];
+  if (values["linkedin-page"])
+    postParams.linkedin_page = values["linkedin-page"];
+  if (values["linkedin-visibility"])
+    postParams.linkedin_visibility = values["linkedin-visibility"];
+  if (values["facebook-title"])
+    postParams.facebook_title = values["facebook-title"];
+  if (values["facebook-description"])
+    postParams.facebook_description = values["facebook-description"];
+  if (values["facebook-page"])
+    postParams.facebook_page = values["facebook-page"];
+  if (values["facebook-media-type"])
+    postParams.facebook_media_type = values["facebook-media-type"];
+  if (values["facebook-thumbnail-url"])
+    postParams.facebook_thumbnail_url = values["facebook-thumbnail-url"];
+  if (values["x-title"])
+    postParams.x_title = values["x-title"];
+  if (values["x-reply-settings"])
+    postParams.x_reply_settings = values["x-reply-settings"];
+  if (values["threads-title"])
+    postParams.threads_title = values["threads-title"];
+  if (values["pinterest-title"])
+    postParams.pinterest_title = values["pinterest-title"];
+  if (values["pinterest-description"])
+    postParams.pinterest_description = values["pinterest-description"];
+  if (values["pinterest-board"])
+    postParams.pinterest_board = values["pinterest-board"];
+  if (values["pinterest-link"])
+    postParams.pinterest_link = values["pinterest-link"];
+  if (values["pinterest-alt-text"])
+    postParams.pinterest_alt_text = values["pinterest-alt-text"];
+  if (values["reddit-title"])
+    postParams.reddit_title = values["reddit-title"];
+  if (values["reddit-subreddit"])
+    postParams.reddit_subreddit = values["reddit-subreddit"];
+  if (values["reddit-flair"])
+    postParams.reddit_flair = values["reddit-flair"];
+  if (values["bluesky-title"])
+    postParams.bluesky_title = values["bluesky-title"];
+  if (values["dry-run"]) {
+    const formatter2 = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+    if (formatter2.mode() === "json") {
+      formatter2.json({
+        dry_run: true,
+        payload: postParams
+      });
+    } else {
+      formatter2.pretty([
+        formatter2.header("Dry Run - Request Payload:"),
+        "",
+        JSON.stringify(postParams, null, 2)
+      ]);
+    }
+    return;
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.postVideo(postParams);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    if (result.scheduled) {
+      formatter.pretty([
+        formatter.success("Video scheduled successfully!"),
+        `  ${formatter.label("Job ID:")}        ${result.job_id}`,
+        `  ${formatter.label("Scheduled for:")} ${result.scheduled_date}`
+      ]);
+    } else if (result.results) {
+      const successCount = Object.values(result.results).filter((r) => r.success).length;
+      const lines = [
+        formatter.success(`Posted to ${successCount} platform${successCount === 1 ? "" : "s"}:`),
+        ""
+      ];
+      for (const [platform, platformResult] of Object.entries(result.results)) {
+        if (platformResult.success && platformResult.url) {
+          lines.push(`  ${platform.padEnd(12)} ${platformResult.url}`);
+        } else if (!platformResult.success && platformResult.error) {
+          lines.push(`  ${platform.padEnd(12)} ${formatter.color("FAILED", "RED")} - ${platformResult.error}`);
+        }
+      }
+      if (result.usage) {
+        lines.push("");
+        lines.push(`Usage: ${result.usage.count} / ${result.usage.limit} (${result.usage.remaining} remaining)`);
+      }
+      formatter.pretty(lines);
+    } else {
+      formatter.pretty([
+        formatter.success("Video upload queued successfully!"),
+        `  ${formatter.label("Request ID:")} ${result.request_id || "N/A"}`,
+        "",
+        "Use 'posterboy status <request_id>' to check upload status."
+      ]);
+    }
+  }
+}
+
+// src/commands/post/document.ts
+import { parseArgs as parseArgs9 } from "node:util";
+async function validateDocumentFile(filePath) {
+  const validExts = [".pdf", ".ppt", ".pptx", ".doc", ".docx"];
+  const maxSize = 100 * 1024 * 1024;
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new UserError(`File not found: ${filePath}`);
+  }
+  if (file.size > maxSize) {
+    throw new UserError(`File exceeds 100MB limit: ${filePath} (${(file.size / (1024 * 1024)).toFixed(1)}MB)`);
+  }
+  const ext = filePath.toLowerCase().match(/\.([^./\\]+)$/)?.[1];
+  if (!ext || !validExts.includes(`.${ext}`)) {
+    throw new UserError(`Unsupported format: ${filePath}. Supported: PDF, PPT, PPTX, DOC, DOCX`);
+  }
+}
+async function postDocument(args, globalFlags) {
+  const { values } = parseArgs9({
+    args,
+    options: {
+      file: { type: "string" },
+      url: { type: "string" },
+      title: { type: "string" },
+      description: { type: "string" },
+      platforms: { type: "string" },
+      profile: { type: "string" },
+      "linkedin-page": { type: "string" },
+      "linkedin-visibility": { type: "string" },
+      schedule: { type: "string" },
+      timezone: { type: "string" },
+      queue: { type: "boolean", default: false },
+      async: { type: "boolean", default: false },
+      "dry-run": { type: "boolean", default: false }
+    },
+    strict: false
+  });
+  validateMutuallyExclusive({
+    "--file": !!values.file,
+    "--url": !!values.url
+  }, "Must provide either --file or --url (not both)");
+  if (!values.title) {
+    throw new UserError("--title is required for document posts");
+  }
+  if (values.file) {
+    await validateDocumentFile(values.file);
+  }
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'post')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  if (values.platforms) {
+    const platformList = values.platforms.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    const nonLinkedin = platformList.filter((p) => p !== "linkedin");
+    if (nonLinkedin.length > 0) {
+      throw new UserError(`Document posts are only supported on LinkedIn. Unsupported: ${nonLinkedin.join(", ")}`);
+    }
+  }
+  if (values.schedule && values.queue) {
+    throw new UserError(`--schedule and --queue are mutually exclusive.
+` + "Use --schedule for a specific date/time, or --queue to use the next available slot.");
+  }
+  if (values.schedule) {
+    validateISODate(values.schedule);
+  }
+  if (values.timezone) {
+    validateTimezone(values.timezone);
+  }
+  const postParams = {
+    profile,
+    file: values.file,
+    url: values.url,
+    title: values.title
+  };
+  if (values.description)
+    postParams.description = values.description;
+  if (values["linkedin-page"] || config?.platform_defaults?.linkedin?.page_id) {
+    postParams.linkedin_page = values["linkedin-page"] || config?.platform_defaults?.linkedin?.page_id;
+  }
+  if (values["linkedin-visibility"] || config?.platform_defaults?.linkedin?.visibility) {
+    postParams.linkedin_visibility = values["linkedin-visibility"] || config?.platform_defaults?.linkedin?.visibility;
+  }
+  if (values.schedule)
+    postParams.schedule = values.schedule;
+  if (values.timezone)
+    postParams.timezone = values.timezone;
+  if (values.queue)
+    postParams.queue = values.queue;
+  if (values.async)
+    postParams.async = values.async;
+  if (values["dry-run"]) {
+    const formatter2 = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+    if (formatter2.mode() === "json") {
+      formatter2.json({
+        dry_run: true,
+        payload: postParams
+      });
+    } else {
+      formatter2.pretty([
+        formatter2.header("Dry Run - Request Payload:"),
+        "",
+        JSON.stringify(postParams, null, 2)
+      ]);
+    }
+    return;
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.postDocument(postParams);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    if (result.scheduled) {
+      formatter.pretty([
+        formatter.success("Document post scheduled successfully on LinkedIn!"),
+        `  ${formatter.label("Job ID:")}        ${result.job_id}`,
+        `  ${formatter.label("Scheduled for:")} ${result.scheduled_date}`
+      ]);
+    } else if (result.results) {
+      const lines = [
+        formatter.success("Document posted to LinkedIn successfully!"),
+        ""
+      ];
+      for (const [platform, platformResult] of Object.entries(result.results)) {
+        if (platformResult.success && platformResult.url) {
+          lines.push(`  ${platform.padEnd(12)} ${platformResult.url}`);
+        } else if (!platformResult.success && platformResult.error) {
+          lines.push(`  ${platform.padEnd(12)} ${formatter.color("FAILED", "RED")} - ${platformResult.error}`);
+        }
+      }
+      if (result.usage) {
+        lines.push("");
+        lines.push(`Usage: ${result.usage.count} / ${result.usage.limit} (${result.usage.remaining} remaining)`);
+      }
+      formatter.pretty(lines);
+    } else {
+      formatter.pretty([
+        formatter.success("Document post queued successfully!"),
+        `  ${formatter.label("Request ID:")} ${result.request_id || "N/A"}`
+      ]);
+    }
+  }
+}
+
+// src/commands/status.ts
+import { parseArgs as parseArgs10 } from "node:util";
+async function statusCheck(args, globalFlags) {
+  const { values, positionals } = parseArgs10({
+    args,
+    options: {
+      "request-id": { type: "string" },
+      "job-id": { type: "string" },
+      poll: { type: "boolean", default: false },
+      interval: { type: "string" }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  const hasPositional = positionals.length > 0;
+  const hasRequestId = !!values["request-id"];
+  const hasJobId = !!values["job-id"];
+  const idSourceCount = [hasPositional, hasRequestId, hasJobId].filter(Boolean).length;
+  if (idSourceCount > 1) {
+    throw new UserError(`Only one ID source allowed. Provide one of:
+` + `  posterboy status <id>
+` + `  posterboy status --request-id <id>
+` + "  posterboy status --job-id <id>");
+  }
+  let id;
+  let idType = "job_id";
+  if (values["request-id"]) {
+    id = values["request-id"];
+    idType = "request_id";
+  } else if (values["job-id"]) {
+    id = values["job-id"];
+    idType = "job_id";
+  } else if (positionals.length > 0) {
+    id = positionals[0];
+    if (id.startsWith("req_")) {
+      idType = "request_id";
+    }
+  }
+  if (!id) {
+    throw new UserError(`ID required. Provide one of:
+` + `  posterboy status <id>          (job_id or request_id)
+` + `  posterboy status --request-id <id>
+` + "  posterboy status --job-id <id>");
+  }
+  const pollInterval = values.interval ? parseInt(values.interval, 10) * 1000 : 5000;
+  if (isNaN(pollInterval) || pollInterval < 1000) {
+    throw new UserError("Poll interval must be at least 1 second");
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (values.poll) {
+    const isTTY = process.stdout.isTTY;
+    let attempts = 0;
+    const maxAttempts = 120;
+    let interrupted = false;
+    const sigintHandler = () => {
+      interrupted = true;
+      if (isTTY) {
+        console.log(`
+
+Polling interrupted by user.`);
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", sigintHandler);
+    while (attempts < maxAttempts && !interrupted) {
+      const result = await client.getStatus(id, idType);
+      if (result.status === "completed" || result.status === "failed") {
+        process.off("SIGINT", sigintHandler);
+        if (formatter.mode() === "json") {
+          formatter.json(result);
+        } else {
+          displayPrettyStatus(result, formatter);
+        }
+        return;
+      }
+      if (isTTY) {
+        const dots = ".".repeat(attempts % 3 + 1);
+        process.stdout.write(`\rPolling status${dots}   `);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      attempts++;
+    }
+    process.off("SIGINT", sigintHandler);
+    if (attempts >= maxAttempts) {
+      throw new UserError("Polling timeout reached. Status is still pending. Try again later.");
+    }
+  } else {
+    const result = await client.getStatus(id, idType);
+    if (formatter.mode() === "json") {
+      formatter.json(result);
+    } else {
+      displayPrettyStatus(result, formatter);
+    }
+  }
+}
+function displayPrettyStatus(result, formatter) {
+  const lines = [];
+  if (result.status === "completed") {
+    lines.push(formatter.success("Status: Completed"));
+  } else if (result.status === "failed") {
+    lines.push(formatter.color("Status: Failed", "RED"));
+  } else {
+    lines.push(`Status: ${result.status}`);
+  }
+  if (result.error) {
+    lines.push("");
+    lines.push(formatter.color(`Error: ${result.error}`, "RED"));
+  }
+  if (result.results) {
+    lines.push("");
+    lines.push(formatter.header("Platform Results:"));
+    for (const [platform, platformResult] of Object.entries(result.results)) {
+      const pr = platformResult;
+      if (pr.success && pr.url) {
+        lines.push(`  ${platform.padEnd(12)} ${pr.url}`);
+      } else if (!pr.success && pr.error) {
+        lines.push(`  ${platform.padEnd(12)} ${formatter.color("FAILED", "RED")} - ${pr.error}`);
+      }
+    }
+  }
+  formatter.pretty(lines);
+}
+
+// src/commands/schedule/list.ts
+import { parseArgs as parseArgs11 } from "node:util";
+async function scheduleList(args, globalFlags) {
+  const { values } = parseArgs11({
+    args,
+    options: {
+      profile: { type: "string" }
+    },
+    strict: false
+  });
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  const result = await client.listScheduledPosts(profile);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    if (result.count === 0) {
+      formatter.pretty([
+        formatter.muted("No scheduled posts found.")
+      ]);
+    } else {
+      const lines = [
+        formatter.header(`Scheduled Posts (${result.count})`),
+        ""
+      ];
+      for (const post of result.scheduled_posts) {
+        const platformsList = post.platforms.join(", ");
+        const title = post.title || "(no title)";
+        lines.push(`  ${formatter.label("Job ID:")}     ${post.job_id}`);
+        lines.push(`  ${formatter.label("Date:")}       ${post.scheduled_date}`);
+        lines.push(`  ${formatter.label("Platforms:")}  ${platformsList}`);
+        lines.push(`  ${formatter.label("Type:")}       ${post.content_type}`);
+        lines.push(`  ${formatter.label("Title:")}      ${title}`);
+        lines.push(`  ${formatter.label("Profile:")}    ${post.profile}`);
+        lines.push("");
+      }
+      formatter.pretty(lines);
+    }
+  }
+}
+
+// src/commands/schedule/cancel.ts
+import { parseArgs as parseArgs12 } from "node:util";
+async function scheduleCancel(args, globalFlags) {
+  const { values } = parseArgs12({
+    args,
+    options: {
+      "job-id": { type: "string" },
+      confirm: { type: "boolean", default: false }
+    },
+    strict: false
+  });
+  if (!values["job-id"]) {
+    throw new UserError(`Job ID required.
+` + "Usage: posterboy schedule cancel --job-id <id> [--confirm]");
+  }
+  const jobId = values["job-id"];
+  const confirmed = values.confirm;
+  if (!confirmed && process.stdout.isTTY) {
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(`Cancel scheduled post ${jobId}? (y/n): `, resolve);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+      console.log("Cancelled.");
+      return;
+    }
+  } else if (!confirmed && !process.stdout.isTTY) {
+    throw new UserError(`Confirmation required for non-interactive mode.
+Use --confirm flag to proceed without prompt.`);
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.cancelScheduledPost(jobId);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({ success: result.success, job_id: jobId });
+  } else {
+    formatter.pretty([
+      formatter.success(`Scheduled post ${jobId} cancelled.`)
+    ]);
+  }
+}
+
+// src/commands/schedule/modify.ts
+import { parseArgs as parseArgs13 } from "node:util";
+async function scheduleModify(args, globalFlags) {
+  const { values } = parseArgs13({
+    args,
+    options: {
+      "job-id": { type: "string" },
+      schedule: { type: "string" },
+      title: { type: "string" },
+      timezone: { type: "string" }
+    },
+    strict: false
+  });
+  if (!values["job-id"]) {
+    throw new UserError(`Job ID required.
+` + "Usage: posterboy schedule modify --job-id <id> [--schedule <datetime>] [--title <text>] [--timezone <tz>]");
+  }
+  const jobId = values["job-id"];
+  const updates = {};
+  if (values.schedule) {
+    const scheduleDate = values.schedule;
+    validateISODate(scheduleDate);
+    updates.schedule = scheduleDate;
+  }
+  if (values.title) {
+    updates.title = values.title;
+  }
+  if (values.timezone) {
+    const tz = values.timezone;
+    validateTimezone(tz);
+    updates.timezone = tz;
+  }
+  if (Object.keys(updates).length === 0) {
+    throw new UserError(`At least one update required.
+` + "Provide one of: --schedule, --title, or --timezone");
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.modifyScheduledPost(jobId, updates);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json({ success: result.success, job_id: jobId });
+  } else {
+    formatter.pretty([
+      formatter.success(`Scheduled post ${jobId} updated.`)
+    ]);
+  }
+}
+
+// src/commands/queue/settings.ts
+import { parseArgs as parseArgs14 } from "node:util";
+function validateTimeSlot(slot) {
+  const timePattern = /^([0-1][0-9]|2[0-3]):([0-5][0-9])$/;
+  if (!timePattern.test(slot)) {
+    throw new UserError(`Invalid time slot format: ${slot}
+` + `Expected format: HH:MM (24-hour time, e.g., 09:00, 14:30, 23:45)`);
+  }
+  return true;
+}
+function parseTimeSlots(slotsString) {
+  const slots = slotsString.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (slots.length === 0) {
+    throw new UserError("At least one time slot is required");
+  }
+  if (slots.length > 24) {
+    throw new UserError(`Maximum 24 time slots allowed. You provided ${slots.length}.`);
+  }
+  slots.forEach((slot) => validateTimeSlot(slot));
+  return slots;
+}
+function parseDaysOfWeek(daysString) {
+  const dayMap = {
+    "0": "sun",
+    "1": "mon",
+    "2": "tue",
+    "3": "wed",
+    "4": "thu",
+    "5": "fri",
+    "6": "sat",
+    sun: "sun",
+    mon: "mon",
+    tue: "tue",
+    wed: "wed",
+    thu: "thu",
+    fri: "fri",
+    sat: "sat",
+    sunday: "sun",
+    monday: "mon",
+    tuesday: "tue",
+    wednesday: "wed",
+    thursday: "thu",
+    friday: "fri",
+    saturday: "sat"
+  };
+  const days = daysString.split(",").map((d) => d.trim().toLowerCase()).filter((d) => d.length > 0);
+  if (days.length === 0) {
+    throw new UserError("At least one day of the week is required");
+  }
+  const normalized = days.map((day) => {
+    const normalizedDay = dayMap[day];
+    if (!normalizedDay) {
+      throw new UserError(`Invalid day: ${day}
+` + `Valid days: mon, tue, wed, thu, fri, sat, sun (or 0-6, or full names)`);
+    }
+    return normalizedDay;
+  });
+  return [...new Set(normalized)];
+}
+async function queueSettings(args, globalFlags) {
+  const { values } = parseArgs14({
+    args,
+    options: {
+      profile: { type: "string" },
+      "set-timezone": { type: "string" },
+      "set-slots": { type: "string" },
+      "set-days": { type: "string" }
+    },
+    strict: false
+  });
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'queue')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const isUpdate = !!(values["set-timezone"] || values["set-slots"] || values["set-days"]);
+  if (isUpdate) {
+    const updates = {};
+    if (values["set-timezone"]) {
+      const timezone = values["set-timezone"];
+      validateTimezone(timezone);
+      updates.timezone = timezone;
+    }
+    if (values["set-slots"]) {
+      updates.slots = parseTimeSlots(values["set-slots"]);
+    }
+    if (values["set-days"]) {
+      updates.days_of_week = parseDaysOfWeek(values["set-days"]);
+    }
+    await client.updateQueueSettings(profile, updates);
+    const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+    if (formatter.mode() === "json") {
+      formatter.json({ success: true });
+    } else {
+      formatter.pretty([formatter.success("Queue settings updated.")]);
+    }
+  } else {
+    const settings = await client.getQueueSettings(profile);
+    const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+    if (formatter.mode() === "json") {
+      formatter.json(settings);
+    } else {
+      const lines = [
+        formatter.header("Queue Settings:"),
+        "",
+        `  ${formatter.label("Profile:")}      ${settings.profile}`,
+        `  ${formatter.label("Timezone:")}     ${settings.timezone}`,
+        `  ${formatter.label("Time Slots:")}   ${settings.slots.join(", ")}`,
+        `  ${formatter.label("Days Active:")}  ${settings.days_of_week.join(", ")}`
+      ];
+      formatter.pretty(lines);
+    }
+  }
+}
+
+// src/commands/queue/preview.ts
+import { parseArgs as parseArgs15 } from "node:util";
+async function queuePreview(args, globalFlags) {
+  const { values } = parseArgs15({
+    args,
+    options: {
+      profile: { type: "string" },
+      count: { type: "string" }
+    },
+    strict: false
+  });
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'queue')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  let count = 10;
+  if (values.count) {
+    const parsed = parseInt(values.count, 10);
+    if (isNaN(parsed) || parsed < 1 || parsed > 50) {
+      throw new UserError(`Invalid count: ${values.count}
+` + `Count must be a number between 1 and 50`);
+    }
+    count = parsed;
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.previewQueue(profile, count);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    const lines = [
+      formatter.header(`Next ${result.slots.length} Queue Slots:`),
+      ""
+    ];
+    if (result.slots.length === 0) {
+      lines.push("  No upcoming slots available.");
+    } else {
+      const headers = ["Datetime", "Status"];
+      const rows = result.slots.map((slot) => [
+        slot.datetime,
+        slot.available ? formatter.success("Available") : formatter.muted("Occupied")
+      ]);
+      const col1Width = Math.max(headers[0].length, ...rows.map((r) => r[0].length));
+      lines.push(`  ${formatter.color(headers[0].padEnd(col1Width), "CYAN")}  ${formatter.color(headers[1], "CYAN")}`);
+      rows.forEach((row) => {
+        lines.push(`  ${row[0].padEnd(col1Width)}  ${row[1]}`);
+      });
+    }
+    formatter.pretty(lines);
+  }
+}
+
+// src/commands/queue/next.ts
+import { parseArgs as parseArgs16 } from "node:util";
+async function queueNext(args, globalFlags) {
+  const { values } = parseArgs16({
+    args,
+    options: {
+      profile: { type: "string" }
+    },
+    strict: false
+  });
+  const config = readConfig();
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  if (!profile) {
+    throw new UserError(`Profile required. Provide one of:
+` + `  --profile <name>                           (command flag)
+` + `  --profile <name> (global flag)             (before 'queue')
+` + `  POSTERBOY_PROFILE=<name>                   (environment variable)
+` + '  "default_profile": "<name>"                (in ~/.posterboy/config.json)');
+  }
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.nextSlot(profile);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    formatter.pretty([
+      formatter.success(`Next available slot: ${result.next_slot}`)
+    ]);
+  }
+}
+
+// src/commands/history.ts
+import { parseArgs as parseArgs17 } from "node:util";
+async function history(args, globalFlags) {
+  const { values } = parseArgs17({
+    args,
+    options: {
+      profile: { type: "string" },
+      page: { type: "string" },
+      limit: { type: "string" }
+    },
+    strict: false
+  });
+  const page = values.page ? parseInt(values.page, 10) : 1;
+  if (isNaN(page) || page < 1) {
+    throw new UserError("Page must be a positive integer (>= 1)");
+  }
+  const limit = values.limit ? parseInt(values.limit, 10) : 10;
+  if (isNaN(limit) || limit < 1 || limit > 100) {
+    throw new UserError("Limit must be between 1 and 100");
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const profile = values.profile || globalFlags.profile || getDefaultProfile(undefined, config);
+  const result = await client.getHistory(profile, page, limit);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    if (result.history.length === 0) {
+      formatter.pretty([
+        formatter.muted("No upload history found.")
+      ]);
+    } else {
+      const lines = [
+        formatter.header(`Upload History (page ${result.page} of ${result.total_pages})`),
+        ""
+      ];
+      for (const entry of result.history) {
+        const date = entry.date.substring(0, 16).replace("T", " ");
+        const platformsList = entry.platforms.join(", ");
+        const title = entry.title || "(no title)";
+        const contentType = entry.content_type.padEnd(8);
+        lines.push(`  ${date}  ${contentType}  ${platformsList.padEnd(20)}  ${title}`);
+      }
+      formatter.pretty(lines);
+    }
+  }
+}
+
+// src/commands/analytics.ts
+import { parseArgs as parseArgs18 } from "node:util";
+async function analytics(args, globalFlags) {
+  const { values, positionals } = parseArgs18({
+    args,
+    options: {
+      platforms: { type: "string" },
+      "facebook-page": { type: "string" },
+      "linkedin-page": { type: "string" }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  const profile = positionals[0];
+  if (!profile) {
+    throw new UserError(`Profile is required.
+` + "Usage: posterboy analytics <profile> [--platforms <list>]");
+  }
+  const platforms2 = values.platforms ? values.platforms.split(",").map((p) => p.trim()) : undefined;
+  const facebookPage = values["facebook-page"];
+  const linkedinPage = values["linkedin-page"];
+  if (platforms2?.includes("facebook") && !facebookPage) {
+    throw new UserError(`Facebook analytics require --facebook-page flag.
+` + "Usage: posterboy analytics <profile> --platforms facebook --facebook-page <page_id>");
+  }
+  const config = readConfig();
+  const apiKey = getApiKey(globalFlags.apiKey, config?.api_key);
+  const client = new ApiClient(apiKey, { verbose: globalFlags.verbose });
+  const result = await client.getAnalytics(profile, platforms2, facebookPage, linkedinPage);
+  const formatter = createOutputFormatter(globalFlags.json, globalFlags.pretty, true);
+  if (formatter.mode() === "json") {
+    formatter.json(result);
+  } else {
+    const lines = [
+      formatter.header(`Analytics for "${result.profile}"`),
+      ""
+    ];
+    if (Object.keys(result.analytics).length === 0) {
+      lines.push("  No analytics data available.");
+    } else {
+      for (const [platform, metrics] of Object.entries(result.analytics)) {
+        lines.push(`  ${formatter.label(platform)}`);
+        for (const [key, value] of Object.entries(metrics)) {
+          const formattedKey = key.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+          let formattedValue;
+          if (typeof value === "number") {
+            formattedValue = value.toLocaleString();
+          } else {
+            formattedValue = String(value);
+          }
+          lines.push(`    ${formattedKey.padEnd(15)} ${formattedValue}`);
+        }
+        lines.push("");
+      }
+    }
+    formatter.pretty(lines);
+  }
+}
+
+// src/commands/completions.ts
+import { parseArgs as parseArgs19 } from "node:util";
+var BASH_COMPLETION = `# posterboy bash completion
+_posterboy() {
+  local cur prev commands
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="auth profiles post schedule status history queue platforms analytics completions"
+
+  case "\${prev}" in
+    posterboy)
+      COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+      ;;
+    auth)
+      COMPREPLY=($(compgen -W "login status" -- "\${cur}"))
+      ;;
+    profiles)
+      COMPREPLY=($(compgen -W "list create delete connect" -- "\${cur}"))
+      ;;
+    post)
+      COMPREPLY=($(compgen -W "text photo video document" -- "\${cur}"))
+      ;;
+    schedule)
+      COMPREPLY=($(compgen -W "list cancel modify" -- "\${cur}"))
+      ;;
+    queue)
+      COMPREPLY=($(compgen -W "settings preview next" -- "\${cur}"))
+      ;;
+    platforms)
+      COMPREPLY=($(compgen -W "pages" -- "\${cur}"))
+      ;;
+    pages)
+      COMPREPLY=($(compgen -W "facebook linkedin pinterest" -- "\${cur}"))
+      ;;
+    completions)
+      COMPREPLY=($(compgen -W "bash zsh fish" -- "\${cur}"))
+      ;;
+    *)
+      COMPREPLY=($(compgen -W "--json --pretty --verbose --profile --config --api-key --help --version" -- "\${cur}"))
+      ;;
+  esac
+}
+
+complete -F _posterboy posterboy
+`;
+var ZSH_COMPLETION = `#compdef posterboy
+# posterboy zsh completion
+
+_posterboy() {
+  local curcontext="$curcontext" state line
+  typeset -A opt_args
+
+  _arguments -C \\
+    '1: :->command' \\
+    '*:: :->args' \\
+    '--json[Force JSON output]' \\
+    '--pretty[Force pretty output]' \\
+    '--verbose[Show request/response details]' \\
+    '--config[Override config file path]:file:_files' \\
+    '--api-key[Override API key]:key:' \\
+    '--profile[Override default profile]:profile:' \\
+    '--help[Print help]' \\
+    '--version[Print version]'
+
+  case $state in
+    command)
+      local -a commands
+      commands=(
+        'auth:Authentication and account management'
+        'profiles:Profile management'
+        'post:Content posting'
+        'schedule:Scheduled post management'
+        'status:Check upload status'
+        'history:View upload history'
+        'queue:Queue management'
+        'platforms:List connected platforms'
+        'analytics:View profile analytics'
+        'completions:Generate shell completions'
+      )
+      _describe 'command' commands
+      ;;
+    args)
+      case $line[1] in
+        auth)
+          _arguments '1: :(login status)'
+          ;;
+        profiles)
+          _arguments '1: :(list create delete connect)'
+          ;;
+        post)
+          _arguments '1: :(text photo video document)'
+          ;;
+        schedule)
+          _arguments '1: :(list cancel modify)'
+          ;;
+        queue)
+          _arguments '1: :(settings preview next)'
+          ;;
+        platforms)
+          _arguments '1: :(pages)' '2: :(facebook linkedin pinterest)'
+          ;;
+        completions)
+          _arguments '1: :(bash zsh fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_posterboy
+`;
+var FISH_COMPLETION = `# posterboy fish completion
+
+# Global options
+complete -c posterboy -l json -d "Force JSON output"
+complete -c posterboy -l pretty -d "Force pretty output"
+complete -c posterboy -l verbose -d "Show request/response details"
+complete -c posterboy -l config -d "Override config file path" -r
+complete -c posterboy -l api-key -d "Override API key" -r
+complete -c posterboy -l profile -d "Override default profile" -r
+complete -c posterboy -l help -d "Print help"
+complete -c posterboy -l version -d "Print version"
+
+# Main commands
+complete -c posterboy -f -n "__fish_use_subcommand" -a "auth" -d "Authentication and account management"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "profiles" -d "Profile management"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "post" -d "Content posting"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "schedule" -d "Scheduled post management"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "status" -d "Check upload status"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "history" -d "View upload history"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "queue" -d "Queue management"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "platforms" -d "List connected platforms"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "analytics" -d "View profile analytics"
+complete -c posterboy -f -n "__fish_use_subcommand" -a "completions" -d "Generate shell completions"
+
+# auth subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from auth" -a "login" -d "Store API key in config"
+complete -c posterboy -f -n "__fish_seen_subcommand_from auth" -a "status" -d "Show account info"
+
+# profiles subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from profiles" -a "list" -d "List all connected profiles"
+complete -c posterboy -f -n "__fish_seen_subcommand_from profiles" -a "create" -d "Create a new profile"
+complete -c posterboy -f -n "__fish_seen_subcommand_from profiles" -a "delete" -d "Delete a profile"
+complete -c posterboy -f -n "__fish_seen_subcommand_from profiles" -a "connect" -d "Generate JWT URL"
+
+# post subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from post" -a "text" -d "Post text content"
+complete -c posterboy -f -n "__fish_seen_subcommand_from post" -a "photo" -d "Post photo/carousel"
+complete -c posterboy -f -n "__fish_seen_subcommand_from post" -a "video" -d "Post video content"
+complete -c posterboy -f -n "__fish_seen_subcommand_from post" -a "document" -d "Post document (LinkedIn)"
+
+# schedule subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from schedule" -a "list" -d "List scheduled posts"
+complete -c posterboy -f -n "__fish_seen_subcommand_from schedule" -a "cancel" -d "Cancel a scheduled post"
+complete -c posterboy -f -n "__fish_seen_subcommand_from schedule" -a "modify" -d "Modify a scheduled post"
+
+# queue subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from queue" -a "settings" -d "View or update queue config"
+complete -c posterboy -f -n "__fish_seen_subcommand_from queue" -a "preview" -d "Preview upcoming queue slots"
+complete -c posterboy -f -n "__fish_seen_subcommand_from queue" -a "next" -d "Get next available slot"
+
+# platforms subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from platforms" -a "pages" -d "List platform-specific pages/boards"
+
+# platforms pages subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from pages" -a "facebook" -d "List Facebook pages"
+complete -c posterboy -f -n "__fish_seen_subcommand_from pages" -a "linkedin" -d "List LinkedIn pages"
+complete -c posterboy -f -n "__fish_seen_subcommand_from pages" -a "pinterest" -d "List Pinterest boards"
+
+# completions subcommands
+complete -c posterboy -f -n "__fish_seen_subcommand_from completions" -a "bash" -d "Generate bash completion"
+complete -c posterboy -f -n "__fish_seen_subcommand_from completions" -a "zsh" -d "Generate zsh completion"
+complete -c posterboy -f -n "__fish_seen_subcommand_from completions" -a "fish" -d "Generate fish completion"
+`;
+async function completions(args, _globalFlags) {
+  const { positionals } = parseArgs19({
+    args,
+    options: {},
+    strict: false,
+    allowPositionals: true
+  });
+  const [shell] = positionals;
+  if (!shell) {
+    throw new UserError(`Shell type required. Specify one of: bash, zsh, fish
+
+` + `Examples:
+` + `  posterboy completions bash > /etc/bash_completion.d/posterboy
+` + `  posterboy completions zsh > ~/.zsh/completions/_posterboy
+` + "  posterboy completions fish > ~/.config/fish/completions/posterboy.fish");
+  }
+  switch (shell.toLowerCase()) {
+    case "bash":
+      console.log(BASH_COMPLETION);
+      break;
+    case "zsh":
+      console.log(ZSH_COMPLETION);
+      break;
+    case "fish":
+      console.log(FISH_COMPLETION);
+      break;
+    default:
+      throw new UserError(`Unknown shell: ${shell}
+` + "Supported shells: bash, zsh, fish");
+  }
+}
+
+// src/lib/output.ts
+var ANSI2 = {
+  BOLD: "\x1B[1m",
+  CYAN: "\x1B[36m",
+  YELLOW: "\x1B[33m",
+  GREEN: "\x1B[32m",
+  RED: "\x1B[31m",
+  GRAY: "\x1B[90m",
+  RESET: "\x1B[0m"
+};
+
+class OutputFormatter2 {
+  _mode;
+  _colorEnabled;
+  constructor(forceMode, colorEnabled = true) {
+    if (forceMode) {
+      this._mode = forceMode;
+    } else if (!process.stdout.isTTY) {
+      this._mode = "json";
+    } else {
+      this._mode = "pretty";
+    }
+    this._colorEnabled = colorEnabled && !process.env.NO_COLOR;
+  }
+  mode() {
+    return this._mode;
+  }
+  json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+  pretty(lines) {
+    console.log(lines.join(`
+`));
+  }
+  error(message, details) {
+    const prefix = this.color("Error:", "RED");
+    console.error(`${prefix} ${message}`);
+    if (details) {
+      console.error(details);
+    }
+  }
+  usage(count, limit) {
+    const remaining = limit - count;
+    const line = `Usage: ${count} / ${limit} (${remaining} remaining)`;
+    if (this._mode === "json") {
+      return;
+    }
+    console.log(`
+` + line);
+  }
+  table(headers, rows) {
+    if (this._mode === "json") {
+      return;
+    }
+    const widths = headers.map((h, i) => {
+      const maxRowWidth = Math.max(...rows.map((r) => (r[i] || "").length));
+      return Math.max(h.length, maxRowWidth);
+    });
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+    console.log(this.color(headerLine, "CYAN"));
+    rows.forEach((row) => {
+      const rowLine = row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+      console.log(rowLine);
+    });
+  }
+  color(text, colorName) {
+    if (!this._colorEnabled) {
+      return text;
+    }
+    return `${ANSI2[colorName]}${text}${ANSI2.RESET}`;
+  }
+  header(text) {
+    return this.color(text, "CYAN");
+  }
+  label(text) {
+    return this.color(text, "BOLD");
+  }
+  success(text) {
+    return this.color(text, "GREEN");
+  }
+  warning(text) {
+    return this.color(text, "YELLOW");
+  }
+  muted(text) {
+    return this.color(text, "GRAY");
+  }
+}
+function createOutputFormatter2(jsonFlag, prettyFlag, colorEnabled = true) {
+  let mode;
+  if (jsonFlag) {
+    mode = "json";
+  } else if (prettyFlag) {
+    mode = "pretty";
+  }
+  return new OutputFormatter2(mode, colorEnabled);
+}
+
+// src/lib/errors.ts
+class PosterBoyError2 extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  json() {
+    return {
+      success: false,
+      error: this.message,
+      code: this.name.replace(/Error$/, "").toUpperCase()
+    };
+  }
+}
+
+class UserError2 extends PosterBoyError2 {
+  exitCode = EXIT_CODES.USER_ERROR;
+}
+
+class ApiError2 extends PosterBoyError2 {
+  exitCode = EXIT_CODES.API_ERROR;
+  statusCode;
+  apiMessage;
+  constructor(message, statusCode, apiMessage) {
+    super(message);
+    this.statusCode = statusCode;
+    this.apiMessage = apiMessage || message;
+  }
+  json() {
+    return {
+      success: false,
+      error: this.message,
+      code: "API_ERROR",
+      statusCode: this.statusCode,
+      apiMessage: this.apiMessage
+    };
+  }
+}
+
+class NetworkError2 extends PosterBoyError2 {
+  exitCode = EXIT_CODES.NETWORK_ERROR;
+}
+function suggestFix(error) {
+  const msg = error.message.toLowerCase();
+  if (msg.includes("api key") || msg.includes("unauthorized") || msg.includes("authentication")) {
+    return "Run 'posterboy auth login --key <your-key>' to set up authentication";
+  }
+  if (msg.includes("profile required") || msg.includes("profile not found")) {
+    return "Set a default profile: posterboy profiles create --username <name>";
+  }
+  if (msg.includes("platform") && (msg.includes("not connected") || msg.includes("invalid"))) {
+    return "See available platforms: posterboy platforms --profile <name>";
+  }
+  if (msg.includes("file not found") || msg.includes("no such file")) {
+    return "Check that the file path is correct and the file exists";
+  }
+  return null;
+}
+
+// src/lib/suggestions.ts
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0;i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= b.length; i++) {
+    for (let j = 1;j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function suggestCommand(input) {
+  const commands = [
+    "auth",
+    "profiles",
+    "post",
+    "schedule",
+    "status",
+    "history",
+    "queue",
+    "platforms",
+    "analytics",
+    "completions"
+  ];
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  for (const cmd of commands) {
+    const distance = levenshteinDistance(input, cmd);
+    if (distance < bestDistance && distance <= 3) {
+      bestDistance = distance;
+      bestMatch = cmd;
+    }
+  }
+  return bestMatch;
+}
+
+// src/index.ts
+var HELP_TEXT = `posterboy - Social media posting CLI
+
+USAGE:
+  posterboy [global-options] <command> <subcommand> [flags]
+
+GLOBAL OPTIONS:
+  --json              Force JSON output
+  --pretty            Force pretty output
+  --config <path>     Override config file path
+  --api-key <key>     Override API key
+  --profile <name>    Override default profile
+  --verbose           Show request/response details
+  --version           Print version and exit
+  --help              Print help and exit
+
+COMMANDS:
+  auth                Authentication and account management
+    login             Store API key in config
+    status            Show account info, plan, and usage
+
+  profiles            Profile management
+    list              List all connected profiles
+    create            Create a new profile
+    delete            Delete a profile
+    connect           Generate JWT URL to connect social accounts
+
+  post                Content posting
+    text              Post text content
+    photo             Post photo(s) / carousel
+    video             Post video content
+    document          Post document (LinkedIn only)
+
+  schedule            Scheduled post management
+    list              List all scheduled posts
+    cancel            Cancel a scheduled post
+    modify            Modify a scheduled post
+
+  status              Check upload status
+    <id>              Check status by job_id or request_id
+
+  history             View upload history
+
+  queue               Queue management
+    settings          View or update queue configuration
+    preview           Preview upcoming queue slots
+    next              Get next available queue slot
+
+  platforms           List connected platforms for a profile
+    pages             List platform-specific pages/boards
+      facebook        List Facebook pages
+      linkedin        List LinkedIn pages
+      pinterest       List Pinterest boards
+
+  analytics           View profile analytics
+
+  completions         Generate shell completions
+    bash              Generate bash completion script
+    zsh               Generate zsh completion script
+    fish              Generate fish completion script
+
+EXAMPLES:
+  posterboy auth login --key up_xxxx
+  posterboy auth status
+  posterboy post text --body "Hello!" --platforms x,linkedin
+  posterboy post photo --files photo.jpg --title "My photo" --platforms instagram
+  posterboy history
+  posterboy completions bash > /etc/bash_completion.d/posterboy
+`;
+async function main() {
+  process.stdout.on("error", (err) => {
+    const nodeErr = err;
+    if (nodeErr.code === "EPIPE") {
+      process.exit(0);
+    }
+  });
+  const args = Bun.argv.slice(2);
+  if (args.includes("--version")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (args.includes("--help") || args.length === 0) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+  try {
+    const { values, positionals } = parseArgs20({
+      args,
+      options: {
+        json: { type: "boolean", default: false },
+        pretty: { type: "boolean", default: false },
+        config: { type: "string" },
+        "api-key": { type: "string" },
+        profile: { type: "string" },
+        verbose: { type: "boolean", default: false },
+        version: { type: "boolean" },
+        help: { type: "boolean" }
+      },
+      strict: false,
+      allowPositionals: true
+    });
+    const globalFlags = {
+      json: values.json,
+      pretty: values.pretty,
+      config: values.config,
+      apiKey: values["api-key"],
+      profile: values.profile,
+      verbose: values.verbose
+    };
+    const [command, subcommand, ...remainingArgs] = positionals;
+    switch (command) {
+      case "auth":
+        await handleAuthCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "profiles":
+        await handleProfilesCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "platforms":
+        await handlePlatformsCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "post":
+        await handlePostCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "status":
+        await handleStatusCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "schedule":
+        await handleScheduleCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "queue":
+        await handleQueueCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "history":
+        await history(remainingArgs, globalFlags);
+        break;
+      case "analytics":
+        await handleAnalyticsCommand(subcommand, remainingArgs, globalFlags);
+        break;
+      case "completions":
+        await completions(remainingArgs, globalFlags);
+        break;
+      default: {
+        const suggestion = suggestCommand(command);
+        console.error(`Unknown command: ${command}`);
+        if (suggestion) {
+          console.error(`Did you mean '${suggestion}'?`);
+        }
+        console.error("Run 'posterboy --help' for usage information");
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    await handleError(error);
+  }
+}
+async function handleAuthCommand(subcommand, args, globalFlags) {
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    console.log(`posterboy auth - Authentication and account management
+
+SUBCOMMANDS:
+  login         Store API key in config
+  status        Show account info, plan, and usage
+
+FLAGS:
+  --key         API key (for login)
+  --json        Force JSON output
+  --verbose     Show request/response details
+`);
+    return;
+  }
+  switch (subcommand) {
+    case "login":
+      await authLogin(args, globalFlags);
+      break;
+    case "status":
+      await authStatus(args, globalFlags);
+      break;
+    default:
+      console.error(`Unknown auth subcommand: ${subcommand}`);
+      console.error("Available: login, status");
+      process.exit(1);
+      break;
+  }
+}
+async function handleProfilesCommand(subcommand, args, globalFlags) {
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    console.log(`posterboy profiles - Profile management
+
+SUBCOMMANDS:
+  list          List all connected profiles
+  create        Create a new profile
+  delete        Delete a profile
+  connect       Generate JWT URL to connect social accounts
+
+FLAGS:
+  --username    Profile username (for create/delete/connect)
+  --platforms   Target platforms for connection (for connect)
+  --redirect    Redirect URL after auth (for connect)
+  --json        Force JSON output
+  --verbose     Show request/response details
+`);
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      await profilesList(args, globalFlags);
+      break;
+    case "create":
+      await profilesCreate(args, globalFlags);
+      break;
+    case "delete":
+      await profilesDelete(args, globalFlags);
+      break;
+    case "connect":
+      await profilesConnect(args, globalFlags);
+      break;
+    default:
+      console.error(`Unknown profiles subcommand: ${subcommand}`);
+      console.error("Available: list, create, delete, connect");
+      process.exit(1);
+      break;
+  }
+}
+async function handlePlatformsCommand(subcommand, args, globalFlags) {
+  if (!subcommand) {
+    await platforms(args, globalFlags);
+    return;
+  }
+  if (subcommand === "help" || subcommand === "--help") {
+    console.log(`posterboy platforms - List connected platforms
+
+USAGE:
+  posterboy platforms [--profile <name>]
+  posterboy platforms pages <platform> [--profile <name>]
+
+SUBCOMMANDS:
+  pages         List platform-specific pages/boards
+    facebook    List Facebook pages
+    linkedin    List LinkedIn pages
+    pinterest   List Pinterest boards
+
+FLAGS:
+  --profile     Profile to check platforms for
+  --json        Force JSON output
+  --verbose     Show request/response details
+`);
+    return;
+  }
+  if (subcommand === "pages") {
+    const [platformSubcmd, ...remainingArgs] = args;
+    if (!platformSubcmd) {
+      console.error("Platform required for pages command");
+      console.error("Available: facebook, linkedin, pinterest");
+      process.exit(1);
+    }
+    await platformsPages(platformSubcmd, remainingArgs, globalFlags);
+    return;
+  }
+  console.error(`Unknown platforms subcommand: ${subcommand}`);
+  console.error("Available: pages");
+  process.exit(1);
+}
+async function handlePostCommand(subcommand, args, globalFlags) {
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    console.log(`posterboy post - Content posting
+
+SUBCOMMANDS:
+  text          Post text content
+  photo         Post photo(s) / carousel
+  video         Post video content
+  document      Post document (LinkedIn only)
+
+FLAGS:
+  --profile     Profile to post from
+  --platforms   Target platforms (comma-separated)
+  --schedule    ISO-8601 datetime for scheduling
+  --queue       Add to next queue slot
+  --dry-run     Preview without posting
+  --json        Force JSON output
+  --verbose     Show request/response details
+`);
+    return;
+  }
+  switch (subcommand) {
+    case "text":
+      await postText(args, globalFlags);
+      break;
+    case "photo":
+      await postPhoto(args, globalFlags);
+      break;
+    case "video":
+      await postVideo(args, globalFlags);
+      break;
+    case "document":
+      await postDocument(args, globalFlags);
+      break;
+    default:
+      console.error(`Unknown post subcommand: ${subcommand}`);
+      console.error("Available: text, photo, video, document");
+      process.exit(1);
+      break;
+  }
+}
+async function handleStatusCommand(subcommand, args, globalFlags) {
+  const allArgs = subcommand ? [subcommand, ...args] : args;
+  await statusCheck(allArgs, globalFlags);
+}
+async function handleScheduleCommand(subcommand, args, globalFlags) {
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    console.log(`posterboy schedule - Scheduled post management
+
+SUBCOMMANDS:
+  list          List all scheduled posts
+  cancel        Cancel a scheduled post
+  modify        Modify a scheduled post
+
+FLAGS:
+  --profile     Filter by profile (for list)
+  --id          Job ID (for cancel/modify)
+  --schedule    New schedule time (for modify)
+  --title       New title (for modify)
+  --timezone    New timezone (for modify)
+  --json        Force JSON output
+  --verbose     Show request/response details
+`);
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      await scheduleList(args, globalFlags);
+      break;
+    case "cancel":
+      await scheduleCancel(args, globalFlags);
+      break;
+    case "modify":
+      await scheduleModify(args, globalFlags);
+      break;
+    default:
+      console.error(`Unknown schedule subcommand: ${subcommand}`);
+      console.error("Available: list, cancel, modify");
+      process.exit(1);
+      break;
+  }
+}
+async function handleQueueCommand(subcommand, args, globalFlags) {
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    console.log(`posterboy queue - Queue management
+
+SUBCOMMANDS:
+  settings      View or update queue configuration
+  preview       Preview upcoming queue slots
+  next          Get next available queue slot
+
+FLAGS:
+  --profile     Profile to manage queue for
+  --count       Number of slots to preview (for preview)
+  --enabled     Enable/disable queue (for settings)
+  --times       Queue times (comma-separated, for settings)
+  --timezone    Queue timezone (for settings)
+  --json        Force JSON output
+  --verbose     Show request/response details
+`);
+    return;
+  }
+  switch (subcommand) {
+    case "settings":
+      await queueSettings(args, globalFlags);
+      break;
+    case "preview":
+      await queuePreview(args, globalFlags);
+      break;
+    case "next":
+      await queueNext(args, globalFlags);
+      break;
+    default:
+      console.error(`Unknown queue subcommand: ${subcommand}`);
+      console.error("Available: settings, preview, next");
+      process.exit(1);
+      break;
+  }
+}
+async function handleAnalyticsCommand(subcommand, args, globalFlags) {
+  const allArgs = subcommand ? [subcommand, ...args] : args;
+  await analytics(allArgs, globalFlags);
+}
+async function handleError(error) {
+  const formatter = createOutputFormatter2(false, false, true);
+  if (error instanceof PosterBoyError2) {
+    formatter.error(error.message);
+    const fix = suggestFix(error);
+    if (fix) {
+      console.error(`
+Tip: ${fix}`);
+    }
+    process.exit(error.exitCode);
+  } else if (error instanceof Error) {
+    formatter.error(error.message);
+    process.exit(1);
+  } else {
+    formatter.error("An unexpected error occurred");
+    process.exit(1);
+  }
+}
+main();