@wahlu/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1294 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command11 } from "commander";
+
+// src/commands/auth.ts
+import { Command } from "commander";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "wahlu");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function getApiKey() {
+  const envKey = process.env.WAHLU_API_KEY;
+  if (envKey) return envKey;
+  const config = readConfig();
+  if (config.api_key) return config.api_key;
+  console.error(
+    "No API key found. Set WAHLU_API_KEY or run: wahlu auth login"
+  );
+  process.exit(1);
+}
+function getApiUrl() {
+  return process.env.WAHLU_API_URL || readConfig().api_url || "https://api.wahlu.com";
+}
+function getDefaultBrandId() {
+  return process.env.WAHLU_BRAND_ID || readConfig().default_brand_id;
+}
+
+// src/commands/auth.ts
+var authCommand = new Command("auth").description("Authenticate with your Wahlu API key").addHelpText(
+  "after",
+  `
+Manage your Wahlu API key for CLI authentication.
+
+Subcommands:
+  login <key>    Save an API key to ~/.config/wahlu/config.json
+  logout         Remove the saved API key
+  status         Show current authentication state and config
+
+Authentication priority:
+  1. WAHLU_API_KEY environment variable (highest priority)
+  2. Saved key in ~/.config/wahlu/config.json
+
+Generate an API key at wahlu.com under Settings > API Keys.
+Full documentation: https://wahlu.com/docs`
+);
+authCommand.command("login").description("Save your API key").argument("<api-key>", "Your Wahlu API key (wahlu_live_... or wahlu_test_...)").addHelpText(
+  "after",
+  `
+Saves the API key to ~/.config/wahlu/config.json for use in future commands.
+The key must start with wahlu_live_ (production) or wahlu_test_ (development).
+
+Examples:
+  wahlu auth login wahlu_live_abc123def456...
+  wahlu auth login wahlu_test_abc123def456...
+
+You can also skip this and use an environment variable instead:
+  export WAHLU_API_KEY=wahlu_live_abc123...`
+).action((apiKey) => {
+  if (!apiKey.startsWith("wahlu_live_") && !apiKey.startsWith("wahlu_test_")) {
+    console.error(
+      "Invalid API key format. Keys start with wahlu_live_ or wahlu_test_"
+    );
+    process.exit(1);
+  }
+  const config = readConfig();
+  config.api_key = apiKey;
+  writeConfig(config);
+  console.log("API key saved to ~/.config/wahlu/config.json");
+});
+authCommand.command("logout").description("Remove saved API key").addHelpText(
+  "after",
+  `
+Removes the API key from ~/.config/wahlu/config.json.
+Does not affect the WAHLU_API_KEY environment variable.`
+).action(() => {
+  const config = readConfig();
+  delete config.api_key;
+  writeConfig(config);
+  console.log("API key removed.");
+});
+authCommand.command("status").description("Show current auth status").addHelpText(
+  "after",
+  `
+Shows which authentication method is active and any saved configuration.
+
+Displays:
+  - Auth source (env var or config file) and masked key
+  - Custom API URL if set
+  - Default brand ID if set`
+).action(() => {
+  const envKey = process.env.WAHLU_API_KEY;
+  const config = readConfig();
+  if (envKey) {
+    console.log(
+      `Authenticated via WAHLU_API_KEY env var (${mask(envKey)})`
+    );
+  } else if (config.api_key) {
+    console.log(
+      `Authenticated via config file (${mask(config.api_key)})`
+    );
+  } else {
+    console.log("Not authenticated. Run: wahlu auth login <api-key>");
+  }
+  if (config.api_url) {
+    console.log(`API URL: ${config.api_url}`);
+  }
+  if (config.default_brand_id) {
+    console.log(`Default brand: ${config.default_brand_id}`);
+  }
+});
+function mask(key) {
+  if (key.length <= 16) return "***";
+  return `${key.slice(0, 12)}...${key.slice(-4)}`;
+}
+
+// src/commands/brand.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/client.ts
+var WahluClient = class {
+  baseUrl;
+  apiKey;
+  constructor(apiKey, baseUrl = "https://api.wahlu.com") {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}/v1${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": "wahlu-cli"
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      let message;
+      try {
+        const json = JSON.parse(text);
+        message = json.error?.message || json.message || `HTTP ${res.status}`;
+      } catch {
+        message = text || `HTTP ${res.status} ${res.statusText}`;
+      }
+      throw new CliError(message, res.status);
+    }
+    return res.json();
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async list(path, page, limit) {
+    const params = new URLSearchParams();
+    if (page !== void 0) params.set("page", String(page));
+    if (limit !== void 0) params.set("limit", String(limit));
+    const qs = params.toString();
+    return this.request(
+      "GET",
+      qs ? `${path}?${qs}` : path
+    );
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+var CliError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "CliError";
+    this.status = status;
+  }
+};
+
+// src/lib/output.ts
+function output(data, opts = {}) {
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (opts.columns && Array.isArray(data)) {
+    printTable(data, opts.columns);
+    return;
+  }
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const record = data;
+    const maxKey = Math.max(...Object.keys(record).map((k) => k.length));
+    for (const [key, value] of Object.entries(record)) {
+      const display = value === null || value === void 0 ? "-" : typeof value === "object" ? JSON.stringify(value) : String(value);
+      console.log(`${key.padEnd(maxKey + 2)}${display}`);
+    }
+    return;
+  }
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    console.log("No results.");
+    return;
+  }
+  const widths = columns.map((col) => {
+    const headerLen = col.header.length;
+    const maxData = rows.reduce((max, row) => {
+      const val = formatCell(row[col.key], col.transform);
+      return Math.max(max, val.length);
+    }, 0);
+    return col.width || Math.min(Math.max(headerLen, maxData), 50);
+  });
+  const header = columns.map((col, i) => col.header.padEnd(widths[i])).join("  ");
+  console.log(header);
+  console.log(widths.map((w) => "\u2500".repeat(w)).join("  "));
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const val = formatCell(row[col.key], col.transform);
+      return truncate(val, widths[i]).padEnd(widths[i]);
+    }).join("  ");
+    console.log(line);
+  }
+}
+function formatCell(value, transform) {
+  if (transform) return transform(value);
+  if (value === null || value === void 0) return "-";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
+
+// src/commands/brand.ts
+var brandCommand = new Command2("brand").description("List brands, view details, set a default brand").addHelpText(
+  "after",
+  `
+A brand represents a social media profile in Wahlu. All posts, media,
+schedules, and queues belong to a brand. Most commands require a brand.
+
+Subcommands:
+  list           List all brands accessible to your API key
+  get <id>       View full details for a brand
+  switch <id>    Set a default brand for all future commands
+
+Setting a default brand:
+  wahlu brand switch <brand-id>
+
+  This saves the brand ID to ~/.config/wahlu/config.json so you don't
+  need --brand on every command. You can also set WAHLU_BRAND_ID as
+  an environment variable.
+
+Full documentation: https://wahlu.com/docs`
+);
+brandCommand.command("list").description("List all brands").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Lists all brands accessible to your API key.
+
+Response fields:
+  id                  string       Brand ID
+  name                string       Brand name
+  description         string|null  Brand description
+  logo_url            string|null  Logo URL
+  timezone            string|null  IANA timezone (e.g. "Australia/Sydney")
+  website             string|null  Brand website URL
+  business_category   string|null  Business category
+  brand_kit           object|null  Brand kit (fonts, colours, voice)
+  content_preferences object|null  CTA, logo frequency settings
+  image_posting       object|null  Image posting preferences
+  video_posting       object|null  Video posting preferences
+  created_at          string       ISO 8601 timestamp
+  updated_at          string       ISO 8601 timestamp
+
+Examples:
+  wahlu brand list
+  wahlu brand list --json`
+).action(async (opts) => {
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.get("/brands");
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "name", header: "Name", width: 30 },
+      { key: "timezone", header: "Timezone", width: 20 },
+      { key: "website", header: "Website", width: 30 }
+    ]
+  });
+});
+brandCommand.command("get").description("Get brand details").argument("<brand-id>", "Brand ID").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns full details for a single brand including brand kit, content
+preferences, and posting configuration.
+
+Examples:
+  wahlu brand get abc123
+  wahlu brand get abc123 --json`
+).action(async (brandId, opts) => {
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.get(`/brands/${brandId}`);
+  output(res.data, { json: opts.json });
+});
+brandCommand.command("switch").description("Set default brand for all commands").argument("<brand-id>", "Brand ID to use as default").addHelpText(
+  "after",
+  `
+Saves the brand ID to ~/.config/wahlu/config.json. All commands that
+require a brand will use this ID unless overridden with --brand.
+
+Examples:
+  wahlu brand switch abc123
+  wahlu post list                     # uses abc123 automatically
+  wahlu post list --brand xyz789      # overrides for this command`
+).action((brandId) => {
+  const config = readConfig();
+  config.default_brand_id = brandId;
+  writeConfig(config);
+  console.log(`Default brand set to ${brandId}`);
+});
+
+// src/commands/idea.ts
+import { Command as Command3 } from "commander";
+
+// src/lib/resolve-brand.ts
+function resolveBrandId(cmd) {
+  const brandId = cmd.optsWithGlobals().brand || getDefaultBrandId();
+  if (!brandId) {
+    console.error(
+      "No brand specified. Use --brand <id>, set WAHLU_BRAND_ID, or run: wahlu brand switch <id>"
+    );
+    process.exit(1);
+  }
+  return brandId;
+}
+
+// src/commands/idea.ts
+var ideaCommand = new Command3("idea").description("Save, list, and manage content ideas").addHelpText(
+  "after",
+  `
+Ideas are a scratchpad for future content concepts. Save ideas as you
+think of them, then develop them into full posts later.
+
+Subcommands:
+  list              List all ideas
+  create <name>     Save a new idea
+  delete <id>       Delete an idea
+
+Full documentation: https://wahlu.com/docs`
+);
+ideaCommand.command("list").description("List all ideas").option("--page <n>", "Page number (default: 1)", parseInt).option("--limit <n>", "Items per page (default: 50, max: 100)", parseInt).option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns a paginated list of content ideas.
+
+Response fields:
+  id            string       Idea ID
+  name          string|null  Idea name/title
+  description   string|null  Detailed description
+  type          string|null  Idea type
+  status        string       Status
+  labels        string[]     Text labels
+  last_used_at  string|null  Last used timestamp
+  created_at    string       ISO 8601 timestamp
+  updated_at    string       ISO 8601 timestamp
+
+Examples:
+  wahlu idea list
+  wahlu idea list --limit 10 --json`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.list(
+    `/brands/${brandId}/ideas`,
+    opts.page,
+    opts.limit
+  );
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "name", header: "Name", width: 40 },
+      { key: "status", header: "Status", width: 12 },
+      { key: "type", header: "Type", width: 12 }
+    ]
+  });
+});
+ideaCommand.command("create").description("Save a new content idea").argument("<name>", "Idea name/title (max 500 chars)").option("--description <text>", "Detailed description (max 10000 chars)").option("--type <type>", "Idea type (max 50 chars)").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Saves a new content idea. Only the name is required.
+
+Fields:
+  <name>             string    Idea name/title (required, max 500 chars)
+  --description      string    Detailed description (max 10000 chars)
+  --type             string    Idea type (max 50 chars)
+
+Examples:
+  wahlu idea create "Blog about summer trends"
+  wahlu idea create "Product launch" --description "Announce the new feature" --type "campaign"
+  wahlu idea create "Quick tip series" --json`
+).action(async function(name, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const body = { name };
+  if (opts.description) body.description = opts.description;
+  if (opts.type) body.type = opts.type;
+  const res = await client.post(`/brands/${brandId}/ideas`, body);
+  output(res.data, { json: opts.json });
+});
+ideaCommand.command("delete").description("Delete an idea").argument("<idea-id>", "Idea ID").addHelpText(
+  "after",
+  `
+Permanently deletes an idea. This cannot be undone.
+
+Examples:
+  wahlu idea delete idea-abc123`
+).action(async function(ideaId) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  await client.delete(`/brands/${brandId}/ideas/${ideaId}`);
+  console.log(`Idea ${ideaId} deleted.`);
+});
+
+// src/commands/integration.ts
+import { Command as Command4 } from "commander";
+var integrationCommand = new Command4("integration").description("View connected social media accounts (read-only)").addHelpText(
+  "after",
+  `
+Integrations are connected social media accounts. You need integration IDs
+when scheduling posts (wahlu schedule create --integrations <id>).
+
+Subcommands:
+  list    List all connected integrations
+
+Integrations are connected and managed in the Wahlu web app.
+This command is read-only \u2014 you cannot connect or disconnect accounts via the CLI.
+
+Full documentation: https://wahlu.com/docs`
+);
+integrationCommand.command("list").description("List connected integrations").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns all connected integrations for the brand (no pagination).
+Credentials (tokens, secrets) are never exposed.
+
+Response fields:
+  id            string       Integration ID (use in --integrations when scheduling)
+  platform      string       Platform: "instagram" | "tiktok" | "facebook" | "youtube" | "linkedin"
+  status        string       Connection status
+  brand_id      string       Brand ID
+  display_name  string|null  Display name on the platform
+  username      string|null  Platform username/handle
+  avatar_url    string|null  Profile avatar URL
+  permissions   object|null  Granted permissions
+  created_at    string       ISO 8601 timestamp
+  updated_at    string       ISO 8601 timestamp
+
+Examples:
+  wahlu integration list
+  wahlu integration list --json
+  wahlu integration list --json | jq '.[] | {id, platform, username}'`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.get(
+    `/brands/${brandId}/integrations`
+  );
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "platform", header: "Platform", width: 12 },
+      { key: "username", header: "Username", width: 20 },
+      { key: "status", header: "Status", width: 12 }
+    ]
+  });
+});
+
+// src/commands/label.ts
+import { Command as Command5 } from "commander";
+var labelCommand = new Command5("label").description("Create and manage labels for organising posts").addHelpText(
+  "after",
+  `
+Labels are used to categorise and organise posts and media.
+
+Subcommands:
+  list              List all labels
+  create <name>     Create a new label
+  delete <id>       Delete a label
+
+Labels can be attached to posts:
+  wahlu post create --name "My post" --labels label-1 label-2
+
+Full documentation: https://wahlu.com/docs`
+);
+labelCommand.command("list").description("List all labels").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns all labels for the brand (no pagination \u2014 returns all at once).
+
+Response fields:
+  id          string       Label ID
+  name        string       Label name
+  color       string|null  Colour hex code (e.g. "#ff5500")
+  created_at  string       ISO 8601 timestamp
+  updated_at  string       ISO 8601 timestamp
+
+Examples:
+  wahlu label list
+  wahlu label list --json`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.get(`/brands/${brandId}/labels`);
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "name", header: "Name", width: 30 },
+      { key: "color", header: "Colour", width: 10 }
+    ]
+  });
+});
+labelCommand.command("create").description("Create a label").argument("<name>", "Label name (required, max 100 chars)").option("--color <hex>", 'Colour hex code (e.g. "#ff5500", max 20 chars)').option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Creates a new label for organising posts and media.
+
+Fields:
+  <name>      string    Label name (required, max 100 chars)
+  --color     string    Colour hex code (optional, max 20 chars)
+
+Examples:
+  wahlu label create "Urgent"
+  wahlu label create "Promo" --color "#ff5500"
+  wahlu label create "Campaign Q1" --json`
+).action(async function(name, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const body = { name };
+  if (opts.color) body.color = opts.color;
+  const res = await client.post(`/brands/${brandId}/labels`, body);
+  output(res.data, { json: opts.json });
+});
+labelCommand.command("delete").description("Delete a label").argument("<label-id>", "Label ID").addHelpText(
+  "after",
+  `
+Permanently deletes a label. This does not remove the label from
+posts that already have it attached.
+
+Examples:
+  wahlu label delete label-abc123`
+).action(async function(labelId) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  await client.delete(`/brands/${brandId}/labels/${labelId}`);
+  console.log(`Label ${labelId} deleted.`);
+});
+
+// src/commands/media.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { basename } from "path";
+import { Command as Command6 } from "commander";
+var MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm"
+};
+var mediaCommand = new Command6("media").description("Upload images/videos and manage your media library").addHelpText(
+  "after",
+  `
+Media files (images and videos) that can be attached to posts via media_ids
+in platform settings.
+
+Subcommands:
+  list              List all media files in the library
+  upload <file>     Upload a local image or video file
+  delete <id>       Permanently delete a media file
+
+Supported formats:
+  Images:  .png, .jpg, .jpeg, .gif, .webp
+  Videos:  .mp4, .mov, .webm
+
+Typical workflow:
+  1. Upload:     wahlu media upload ./photo.jpg
+  2. Get the media ID from the output
+  3. Use in a post:  wahlu post create --name "Photo post" \\
+       --instagram '{"description":"Nice!","post_type":"grid_post","media_ids":["<media-id>"]}'
+
+Full documentation: https://wahlu.com/docs`
+);
+mediaCommand.command("list").description("List media files").option("--page <n>", "Page number (default: 1)", parseInt).option("--limit <n>", "Items per page (default: 50, max: 100)", parseInt).option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns a paginated list of media files for the brand.
+
+Response fields:
+  id                  string       Media ID (use in media_ids arrays)
+  file_name           string       Original filename
+  content_type        string       MIME type (e.g. "image/jpeg", "video/mp4")
+  size                number       File size in bytes
+  duration            number|null  Duration in seconds (video/audio only)
+  status              string       Processing status: "available" | "processing" | "completed" | "failed"
+  workflow_status     string|null  Normalised lifecycle status
+  label_ids           string[]     Attached label IDs
+  folder_id           string|null  Folder ID
+  download_url        string|null  Signed download URL
+  thumbnail_large_url string|null  Large thumbnail URL
+  thumbnail_small_url string|null  Small thumbnail URL
+  source              string|null  Upload source: "upload" | "generated" | "stock" | "scan"
+  description         string|null  Media description
+  last_used_at        string|null  Last used in a post
+  created_at          string       ISO 8601 timestamp
+  updated_at          string       ISO 8601 timestamp
+
+Examples:
+  wahlu media list
+  wahlu media list --limit 10 --json`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.list(
+    `/brands/${brandId}/media`,
+    opts.page,
+    opts.limit
+  );
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "file_name", header: "Filename", width: 30 },
+      { key: "content_type", header: "Type", width: 16 },
+      { key: "status", header: "Status", width: 12 },
+      {
+        key: "size",
+        header: "Size",
+        width: 10,
+        transform: (v) => {
+          if (!v) return "-";
+          const bytes = v;
+          if (bytes < 1024) return `${bytes}B`;
+          if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(0)}KB`;
+          return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+        }
+      }
+    ]
+  });
+});
+mediaCommand.command("upload").description("Upload a local file to the media library").argument("<file>", "Local file path (e.g. ./photo.jpg, ~/videos/clip.mp4)").option("--json", "Output as JSON (returns media ID)").addHelpText(
+  "after",
+  `
+Uploads a local file to your brand's media library. The upload is a 3-step
+process handled automatically:
+  1. Request a signed upload URL from the API
+  2. Upload the file bytes to the signed URL
+  3. Mark the media as available for processing
+
+After upload, Wahlu processes the media (generates thumbnails, etc.).
+Use 'wahlu media list' to check when status changes to "completed".
+
+The returned media ID can be used in post platform settings:
+  --instagram '{"media_ids":["<media-id>"],...}'
+
+Examples:
+  wahlu media upload ./photo.jpg
+  wahlu media upload ~/Desktop/video.mp4 --json`
+).action(async function(filePath, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const filename = basename(filePath);
+  const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
+  const contentType = MIME_TYPES[ext];
+  if (!contentType) {
+    console.error(
+      `Unsupported file type: ${ext}
+Supported: ${Object.keys(MIME_TYPES).join(", ")}`
+    );
+    process.exit(1);
+  }
+  const stat = statSync(filePath);
+  const urlRes = await client.post(`/brands/${brandId}/media/upload-url`, {
+    filename,
+    content_type: contentType,
+    size: stat.size
+  });
+  const { id, upload_url } = urlRes.data;
+  const fileBytes = readFileSync2(filePath);
+  const uploadRes = await fetch(upload_url, {
+    method: "PUT",
+    headers: { "Content-Type": contentType },
+    body: fileBytes
+  });
+  if (!uploadRes.ok) {
+    console.error(`Upload failed: HTTP ${uploadRes.status}`);
+    process.exit(1);
+  }
+  await client.patch(`/brands/${brandId}/media/${id}`, {
+    status: "available"
+  });
+  if (opts.json) {
+    console.log(
+      JSON.stringify({ id, filename, status: "processing" }, null, 2)
+    );
+  } else {
+    console.log(`Uploaded ${filename} \u2014 media ID: ${id}`);
+    console.log(
+      "Processing will complete shortly. Use 'wahlu media list' to check status."
+    );
+  }
+});
+mediaCommand.command("delete").description("Permanently delete a media file").argument("<media-id>", "Media ID").addHelpText(
+  "after",
+  `
+Permanently deletes a media file. This cannot be undone.
+
+Examples:
+  wahlu media delete mid-abc123`
+).action(async function(mediaId) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  await client.delete(`/brands/${brandId}/media/${mediaId}`);
+  console.log(`Media ${mediaId} deleted.`);
+});
+
+// src/commands/post.ts
+import { Command as Command7 } from "commander";
+var postCommand = new Command7("post").description("Create, update, list, and delete posts with per-platform settings").addHelpText(
+  "after",
+  `
+Posts are the core content unit in Wahlu. Each post can have platform-specific
+settings for Instagram, TikTok, Facebook, YouTube, and LinkedIn.
+
+Subcommands:
+  list              List all posts for the brand
+  get <id>          View full post details including platform settings
+  create            Create a new post with optional platform settings
+  update <id>       Update an existing post (only provided fields change)
+  delete <id>       Permanently delete a post
+
+Typical workflow:
+  1. Upload media:       wahlu media upload ./photo.jpg
+  2. Create a post:      wahlu post create --name "My post" --instagram '...'
+  3. Schedule or queue:  wahlu schedule create <post-id> --at <datetime> --integrations <id>
+
+Run 'wahlu post create --help' for full platform settings reference.
+Full documentation: https://wahlu.com/docs`
+);
+postCommand.command("list").description("List posts").option("--page <n>", "Page number (default: 1)", parseInt).option("--limit <n>", "Items per page (default: 50, max: 100)", parseInt).option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns a paginated list of posts for the brand.
+
+Response fields (per post):
+  id                    string       Post ID
+  name                  string|null  Post name
+  brand_id              string       Brand ID
+  label_ids             string[]     Attached label IDs
+  created_by            string|null  Creator user ID
+  thumbnail_timestamp   number       Thumbnail timestamp (seconds)
+  instagram_settings    object|null  Instagram configuration
+  tiktok_settings       object|null  TikTok configuration
+  facebook_settings     object|null  Facebook configuration
+  youtube_settings      object|null  YouTube configuration
+  linkedin_settings     object|null  LinkedIn configuration
+  created_at            string       ISO 8601 timestamp
+  updated_at            string       ISO 8601 timestamp
+
+Examples:
+  wahlu post list
+  wahlu post list --limit 10 --page 2
+  wahlu post list --json | jq '.[].name'`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.list(
+    `/brands/${brandId}/posts`,
+    opts.page,
+    opts.limit
+  );
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "name", header: "Name", width: 40 },
+      {
+        key: "created_at",
+        header: "Created",
+        width: 20,
+        transform: (v) => v ? new Date(v).toLocaleDateString() : "-"
+      }
+    ]
+  });
+  if (!opts.json && res.pagination?.has_more) {
+    console.log(
+      `
+Page ${res.pagination.page} \u2014 more results available (--page ${res.pagination.page + 1})`
+    );
+  }
+});
+postCommand.command("get").description("Get post details").argument("<post-id>", "Post ID").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns full details for a single post including all platform settings.
+
+Examples:
+  wahlu post get abc123
+  wahlu post get abc123 --json`
+).action(async function(postId, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.get(`/brands/${brandId}/posts/${postId}`);
+  output(res.data, { json: opts.json });
+});
+postCommand.command("create").description("Create a new post").option("--name <name>", "Post name (max 500 chars)").option("--instagram <json>", "Instagram settings as JSON string").option("--tiktok <json>", "TikTok settings as JSON string").option("--facebook <json>", "Facebook settings as JSON string").option("--youtube <json>", "YouTube settings as JSON string").option("--linkedin <json>", "LinkedIn settings as JSON string").option("--labels <ids...>", "Label IDs to attach (max 50)").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Creates a new post with optional platform-specific settings. You can target
+multiple platforms in a single post by providing multiple --<platform> flags.
+
+Examples:
+  wahlu post create --name "Monday post" \\
+    --instagram '{"description":"Hello!","post_type":"grid_post"}'
+
+  wahlu post create --name "Cross-platform video" \\
+    --tiktok '{"description":"Check this out","post_type":"video","media_ids":["mid-123"]}' \\
+    --instagram '{"description":"Check this out","post_type":"reel","media_ids":["mid-123"]}'
+
+  wahlu post create --name "Article share" \\
+    --linkedin '{"description":"Read our latest post","post_type":"li_article","original_url":"https://example.com/post","title":"Our Latest Post"}'
+
+Platform settings reference:
+
+  Instagram (--instagram):
+    Field                Type      Values / Description
+    description          string    Caption text
+    post_type            string    "grid_post" | "reel" | "story"
+    media_ids            string[]  Media IDs to attach
+    trial_reel           boolean   Post as trial reel (shown to non-followers first)
+    graduation_strategy  string    "MANUAL" | "SS_PERFORMANCE" (auto-graduate trial reels)
+
+  TikTok (--tiktok):
+    Field                Type      Values / Description
+    description          string    Caption text
+    post_type            string    "video" | "image" | "carousel"
+    media_ids            string[]  Media IDs to attach
+    privacy_level        string    "PUBLIC_TO_EVERYONE" | "MUTUAL_FOLLOW_FRIENDS" | "FOLLOWER_OF_CREATOR" | "SELF_ONLY"
+    allow_comment        boolean   Allow comments (default: true)
+    allow_duet           boolean   Allow duets (default: true, video only)
+    allow_stitch         boolean   Allow stitches (default: true, video only)
+    auto_add_music       boolean   Auto-add music (photo/carousel only)
+    is_aigc              boolean   Disclose as AI-generated content
+    is_commercial_content boolean  Mark as commercial/branded content
+
+  Facebook (--facebook):
+    Field                Type      Values / Description
+    description          string    Caption text
+    post_type            string    "fb_post" | "fb_story" | "fb_reel" | "fb_text"
+    media_ids            string[]  Media IDs to attach
+
+  YouTube (--youtube):
+    Field                Type      Values / Description
+    title                string    Video title
+    description          string    Video description
+    post_type            string    "yt_short" | "yt_video"
+    media_ids            string[]  Media IDs to attach
+    privacy_level        string    "public" | "unlisted" | "private"
+    notify_subscribers   boolean   Notify subscribers on publish
+
+  LinkedIn (--linkedin):
+    Field                Type      Values / Description
+    description          string    Post text
+    post_type            string    "li_text" | "li_image" | "li_video" | "li_article"
+    media_ids            string[]  Media IDs to attach
+    visibility           string    "PUBLIC" | "CONNECTIONS"
+    title                string    Article title (li_article only)
+    original_url         string    Article URL (li_article only)
+
+Full documentation: https://wahlu.com/docs`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const body = {};
+  if (opts.name) body.name = opts.name;
+  if (opts.labels) body.label_ids = opts.labels;
+  if (opts.instagram)
+    body.instagram_settings = JSON.parse(opts.instagram);
+  if (opts.tiktok) body.tiktok_settings = JSON.parse(opts.tiktok);
+  if (opts.facebook)
+    body.facebook_settings = JSON.parse(opts.facebook);
+  if (opts.youtube) body.youtube_settings = JSON.parse(opts.youtube);
+  if (opts.linkedin)
+    body.linkedin_settings = JSON.parse(opts.linkedin);
+  const res = await client.post(`/brands/${brandId}/posts`, body);
+  output(res.data, { json: opts.json });
+});
+postCommand.command("update").description("Update a post (only provided fields are changed)").argument("<post-id>", "Post ID").option("--name <name>", "Post name (max 500 chars)").option("--instagram <json>", "Instagram settings as JSON string").option("--tiktok <json>", "TikTok settings as JSON string").option("--facebook <json>", "Facebook settings as JSON string").option("--youtube <json>", "YouTube settings as JSON string").option("--linkedin <json>", "LinkedIn settings as JSON string").option("--labels <ids...>", "Label IDs to attach (max 50)").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Updates an existing post. Only the fields you provide are changed \u2014
+omitted fields remain unchanged.
+
+Examples:
+  wahlu post update abc123 --name "New name"
+  wahlu post update abc123 --instagram '{"description":"Updated caption"}'
+  wahlu post update abc123 --labels label-1 label-2
+
+See 'wahlu post create --help' for full platform settings reference.
+Full documentation: https://wahlu.com/docs`
+).action(async function(postId, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const body = {};
+  if (opts.name) body.name = opts.name;
+  if (opts.labels) body.label_ids = opts.labels;
+  if (opts.instagram)
+    body.instagram_settings = JSON.parse(opts.instagram);
+  if (opts.tiktok) body.tiktok_settings = JSON.parse(opts.tiktok);
+  if (opts.facebook)
+    body.facebook_settings = JSON.parse(opts.facebook);
+  if (opts.youtube) body.youtube_settings = JSON.parse(opts.youtube);
+  if (opts.linkedin)
+    body.linkedin_settings = JSON.parse(opts.linkedin);
+  const res = await client.patch(
+    `/brands/${brandId}/posts/${postId}`,
+    body
+  );
+  output(res.data, { json: opts.json });
+});
+postCommand.command("delete").description("Permanently delete a post").argument("<post-id>", "Post ID").addHelpText(
+  "after",
+  `
+Permanently deletes a post. This cannot be undone.
+
+Examples:
+  wahlu post delete abc123`
+).action(async function(postId) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  await client.delete(`/brands/${brandId}/posts/${postId}`);
+  console.log(`Post ${postId} deleted.`);
+});
+
+// src/commands/publication.ts
+import { Command as Command8 } from "commander";
+var publicationCommand = new Command8("publication").description("View posts that have been published to platforms (read-only)").addHelpText(
+  "after",
+  `
+Publications are records of posts that have been successfully published
+to social media platforms. This is a read-only view of your publishing history.
+
+Subcommands:
+  list    List all publications
+
+Full documentation: https://wahlu.com/docs`
+);
+publicationCommand.command("list").description("List published posts").option("--page <n>", "Page number (default: 1)", parseInt).option("--limit <n>", "Items per page (default: 50, max: 100)", parseInt).option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns a paginated list of published posts.
+
+Response fields:
+  id              string       Publication ID
+  platform        string       Platform: "instagram" | "tiktok" | "facebook" | "youtube" | "linkedin"
+  post_id         string       Source post ID
+  post_name       string|null  Post name
+  post_type       string|null  Post type (e.g. "grid_post", "reel", "video")
+  media_type      string|null  Media type
+  status          string       "processing" | "published" | "failed"
+  source          string|null  "calendar" (from schedule) or "queue" (from queue)
+  failure_reason  string|null  Failure reason if publishing failed
+  integration_id  string       Integration used for publishing
+  publish_id      string|null  Platform-specific content ID
+  published_at    string       When it was published (ISO 8601)
+  created_at      string       ISO 8601 timestamp
+  updated_at      string       ISO 8601 timestamp
+
+Examples:
+  wahlu publication list
+  wahlu publication list --limit 10 --json
+  wahlu publication list --json | jq '.[] | select(.status == "failed")'`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.list(
+    `/brands/${brandId}/publications`,
+    opts.page,
+    opts.limit
+  );
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "platform", header: "Platform", width: 12 },
+      { key: "post_name", header: "Post", width: 30 },
+      { key: "status", header: "Status", width: 12 },
+      {
+        key: "published_at",
+        header: "Published",
+        width: 20,
+        transform: (v) => v ? new Date(v).toLocaleString() : "-"
+      }
+    ]
+  });
+});
+
+// src/commands/queue.ts
+import { Command as Command9 } from "commander";
+var queueCommand = new Command9("queue").description("View publishing queues and add posts to them").addHelpText(
+  "after",
+  `
+Queues define recurring time slots for automatic post publishing.
+Posts added to a queue are published at the next available slot.
+
+Subcommands:
+  list                       List all queues and their status
+  add <queue-id> <post-id>   Add a post to a queue
+
+Queues are created and configured in the Wahlu web app.
+
+Full documentation: https://wahlu.com/docs`
+);
+queueCommand.command("list").description("List all queues").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns all queues for the brand (no pagination \u2014 returns all at once).
+
+Response fields:
+  id                string       Queue ID
+  name              string       Queue name
+  brand_id          string       Brand ID
+  active            boolean      Whether the queue is active
+  mode              string       Queue mode
+  interval          number|null  Interval between posts
+  interval_unit     string|null  Interval unit
+  times_of_day      string[]     Scheduled times (e.g. ["09:00", "17:00"])
+  timezone          string|null  IANA timezone
+  valid_from        string|null  ISO 8601 start date
+  valid_until       string|null  ISO 8601 end date
+  next_run_at       string|null  Next scheduled publishing time
+  loop              boolean      Whether to loop through posts
+  post_ids          string[]     Ordered list of post IDs in the queue
+  integration_ids   string[]     Integration IDs to publish to
+  skip_count        number       Number of posts skipped
+  created_at        string       ISO 8601 timestamp
+  updated_at        string       ISO 8601 timestamp
+
+Examples:
+  wahlu queue list
+  wahlu queue list --json`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.get(`/brands/${brandId}/queues`);
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "name", header: "Name", width: 30 },
+      {
+        key: "active",
+        header: "Active",
+        width: 8,
+        transform: (v) => v ? "yes" : "no"
+      },
+      { key: "mode", header: "Mode", width: 12 },
+      {
+        key: "next_run_at",
+        header: "Next Run",
+        width: 20,
+        transform: (v) => v ? new Date(v).toLocaleString() : "-"
+      }
+    ]
+  });
+});
+queueCommand.command("add").description("Add a post to a queue").argument("<queue-id>", "Queue ID").argument("<post-id>", "Post ID to add").option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Adds a post to a queue. The post will be published at the queue's
+next available time slot.
+
+Examples:
+  wahlu queue add queue-abc post-xyz
+  wahlu queue add queue-abc post-xyz --json`
+).action(async function(queueId, postId, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.patch(
+    `/brands/${brandId}/queues/${queueId}`,
+    {
+      post_ids: [postId]
+    }
+  );
+  output(res.data, { json: opts.json });
+});
+
+// src/commands/schedule.ts
+import { Command as Command10 } from "commander";
+var scheduleCommand = new Command10("schedule").description("Schedule posts for future publishing to specific integrations").addHelpText(
+  "after",
+  `
+Scheduled posts are queued for publishing at a specific date and time
+to one or more connected social media integrations.
+
+Subcommands:
+  list              List all scheduled posts
+  create <post-id>  Schedule a post for future publishing
+  delete <id>       Remove a post from the schedule (does not delete the post)
+
+Typical workflow:
+  1. Create a post:         wahlu post create --name "My post" --instagram '...'
+  2. Find integration IDs:  wahlu integration list
+  3. Schedule it:           wahlu schedule create <post-id> --at <datetime> --integrations <id>
+
+Full documentation: https://wahlu.com/docs`
+);
+scheduleCommand.command("list").description("List scheduled posts").option("--page <n>", "Page number (default: 1)", parseInt).option("--limit <n>", "Items per page (default: 50, max: 100)", parseInt).option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Returns a paginated list of scheduled posts, sorted by scheduled_at.
+
+Response fields:
+  id                string       Scheduled post ID
+  brand_id          string       Brand ID
+  post_id           string       Referenced post ID
+  scheduled_at      string       ISO 8601 datetime for publishing
+  integration_ids   string[]     Integration IDs to publish to
+  status            string       Status (e.g. "ready_for_publishing", "published", "failed")
+  approval_status   string|null  Approval status
+  source            string|null  "api" for API-created entries
+  failure_reason    string|null  Failure reason if publishing failed
+  thumbnail_url     string|null  Post thumbnail URL
+  created_at        string       ISO 8601 timestamp
+  updated_at        string       ISO 8601 timestamp
+
+Examples:
+  wahlu schedule list
+  wahlu schedule list --limit 5 --json`
+).action(async function(opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.list(
+    `/brands/${brandId}/scheduled-posts`,
+    opts.page,
+    opts.limit
+  );
+  output(res.data, {
+    json: opts.json,
+    columns: [
+      { key: "id", header: "ID", width: 24 },
+      { key: "post_id", header: "Post ID", width: 24 },
+      { key: "status", header: "Status", width: 12 },
+      {
+        key: "scheduled_at",
+        header: "Scheduled At",
+        width: 20,
+        transform: (v) => v ? new Date(v).toLocaleString() : "-"
+      }
+    ]
+  });
+});
+scheduleCommand.command("create").description("Schedule a post for future publishing").argument("<post-id>", "Post ID to schedule (must exist in the brand)").requiredOption(
+  "--at <datetime>",
+  "ISO 8601 datetime (e.g. 2026-03-15T14:00:00Z)"
+).requiredOption(
+  "--integrations <ids...>",
+  "Integration IDs to publish to (max 20)"
+).option("--json", "Output as JSON").addHelpText(
+  "after",
+  `
+Schedules an existing post for future publishing. The post must already
+exist in the brand, and the integration IDs must be connected accounts.
+
+Required fields:
+  <post-id>            The ID of an existing post in this brand
+  --at <datetime>      ISO 8601 datetime (e.g. "2026-03-15T14:00:00Z")
+  --integrations <ids> Space-separated integration IDs
+
+Find integration IDs with: wahlu integration list
+
+Examples:
+  wahlu schedule create post-abc \\
+    --at 2026-03-15T14:00:00Z \\
+    --integrations int-123
+
+  wahlu schedule create post-abc \\
+    --at 2026-03-15T14:00:00Z \\
+    --integrations int-123 int-456 int-789 \\
+    --json`
+).action(async function(postId, opts) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  const res = await client.post(`/brands/${brandId}/scheduled-posts`, {
+    post_id: postId,
+    scheduled_at: opts.at,
+    integration_ids: opts.integrations
+  });
+  output(res.data, { json: opts.json });
+});
+scheduleCommand.command("delete").description("Remove a post from the schedule").argument("<scheduled-post-id>", "Scheduled post ID (not the post ID)").addHelpText(
+  "after",
+  `
+Removes a scheduled post from the publishing queue. The post itself is
+not deleted \u2014 only the schedule entry is removed.
+
+Examples:
+  wahlu schedule delete sched-abc123`
+).action(async function(id) {
+  const brandId = resolveBrandId(this);
+  const client = new WahluClient(getApiKey(), getApiUrl());
+  await client.delete(`/brands/${brandId}/scheduled-posts/${id}`);
+  console.log(`Scheduled post ${id} removed.`);
+});
+
+// src/index.ts
+var program = new Command11().name("wahlu").description("Wahlu CLI \u2014 manage your social media from the terminal").version("0.1.0").option("--brand <id>", "Brand ID (overrides default)").configureHelp({ sortSubcommands: true }).addHelpText(
+  "after",
+  `
+Getting started:
+  1. Generate an API key at wahlu.com under Settings > API Keys
+  2. wahlu auth login <your-api-key>
+  3. wahlu brand list
+  4. wahlu brand switch <brand-id>
+  5. wahlu post list
+
+All list/get/create/update commands support --json for machine-readable output.
+Run 'wahlu <command> --help' for detailed usage, fields, and examples.
+
+Full documentation: https://wahlu.com/docs`
+);
+program.addCommand(authCommand);
+program.addCommand(brandCommand);
+program.addCommand(ideaCommand);
+program.addCommand(integrationCommand);
+program.addCommand(labelCommand);
+program.addCommand(mediaCommand);
+program.addCommand(postCommand);
+program.addCommand(publicationCommand);
+program.addCommand(queueCommand);
+program.addCommand(scheduleCommand);
+program.exitOverride();
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof CliError) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    if (err && typeof err === "object" && "code" in err && err.code === "commander.helpDisplayed") {
+      process.exit(0);
+    }
+    if (err && typeof err === "object" && "code" in err && err.code === "commander.version") {
+      process.exit(0);
+    }
+    throw err;
+  }
+}
+main();