Square Post

import fs from "fs";
import os from "os";
import path from "path";

const BASE_URL_V1 = "https://www.binance.com/bapi/composite/v1/public/pgc/openApi";
const BASE_URL_V2 = "https://www.binance.com/bapi/composite/v2/public/pgc/openApi";
const POLL_INTERVAL_MS = 3000;
const MAX_POLL_RETRIES = 10;
const CONFIG_DIR = path.join(os.homedir(), ".config", "binance-square");
const CONFIG_FILE = path.join(CONFIG_DIR, "openapi-key");

const CONTENT_TYPE_MAP = {
  jpg: "image/jpeg",
  jpeg: "image/jpeg",
  png: "image/png",
  gif: "image/gif",
  webp: "image/webp",
  mp4: "video/mp4",
  mov: "video/quicktime",
  avi: "video/x-msvideo",
  webm: "video/webm",
};

export function getContentType(filePath) {
  const ext = path.extname(filePath).slice(1).toLowerCase();
  return CONTENT_TYPE_MAP[ext] || "application/octet-stream";
}

export function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

export function getConfigFilePath() {
  return CONFIG_FILE;
}

export function maskApiKey(apiKey) {
  if (!apiKey) return "";
  if (apiKey.length <= 9) return `${apiKey.slice(0, 2)}...`;
  return `${apiKey.slice(0, 5)}...${apiKey.slice(-4)}`;
}

export function readSavedApiKey() {
  const keyFile = getConfigFilePath();
  if (!fs.existsSync(keyFile)) return "";
  return fs.readFileSync(keyFile, "utf8").trim();
}

export function saveApiKey(apiKey) {
  const key = apiKey.trim();
  if (!key) {
    throw new Error("Missing Square OpenAPI key");
  }

  const keyFile = getConfigFilePath();
  fs.mkdirSync(path.dirname(keyFile), { recursive: true, mode: 0o700 });
  fs.writeFileSync(keyFile, `${key}\n`, { mode: 0o600 });
  fs.chmodSync(keyFile, 0o600);
  return keyFile;
}

export function resolveApiKey(args = []) {
  if (args.includes("--key")) {
    throw new Error("Do not pass API keys with --key. Set BINANCE_SQUARE_OPENAPI_KEY or save the key locally first.");
  }

  const envKey = process.env.BINANCE_SQUARE_OPENAPI_KEY;
  if (envKey?.trim()) return envKey.trim();

  const savedKey = readSavedApiKey();
  if (savedKey) return savedKey;

  throw new Error(
    `Missing Square OpenAPI key. Set BINANCE_SQUARE_OPENAPI_KEY or save it to ${getConfigFilePath()} first.`,
  );
}

export async function api(endpoint, apiKey, body, baseUrl = BASE_URL_V2) {
  const res = await fetch(`${baseUrl}${endpoint}`, {
    method: "POST",
    headers: {
      "X-Square-OpenAPI-Key": apiKey,
      "Content-Type": "application/json",
      clienttype: "binanceSkill",
    },
    body: JSON.stringify(body),
  });
  const raw = await res.text();

  if (endpoint === "/content/add" && res.status === 504) {
    return { id: null, shareLink: null, publishStatus: "success_without_post_id" };
  }

  let json;
  try {
    json = JSON.parse(raw);
  } catch (error) {
    console.error("API returned non-JSON response", {
      endpoint,
      status: res.status,
      statusText: res.statusText,
      body: raw,
    });
    throw new Error(`API returned non-JSON response: ${res.status} ${res.statusText}`);
  }
  if (json.code !== "000000") {
    throw new Error(`API error [${json.code}]: ${json.message}`);
  }
  return json.data;
}

export async function uploadToS3(presignedUrl, filePath, contentType) {
  const fileBuffer = fs.readFileSync(filePath);
  const res = await fetch(presignedUrl, {
    method: "PUT",
    headers: { "Content-Type": contentType },
    body: fileBuffer,
  });
  if (!res.ok) {
    throw new Error(`S3 upload failed: ${res.status} ${res.statusText}`);
  }
}

export async function uploadImage(apiKey, imgPath) {
  const imageName = path.basename(imgPath);
  const contentTypeHeader = getContentType(imgPath);

  console.log(`Uploading: ${imageName}`);
  const { presignedUrl, fileTicket } = await api("/image/presignedUrl", apiKey, { imageName });

  await uploadToS3(presignedUrl, imgPath, contentTypeHeader);
  console.log(`  Uploaded to S3, polling status...`);

  const imageStatus = await pollImageStatus(apiKey, fileTicket);
  console.log(`  Ready: ${imageStatus.imageUrl}`);
  return imageStatus.imageUrl;
}

export async function pollImageStatus(apiKey, fileTicket) {
  for (let i = 0; i < MAX_POLL_RETRIES; i++) {
    const data = await api("/image/imageStatus", apiKey, { fileTicket });
    if (data.status === 1) return data;
    if (data.status === 2) throw new Error(`Processing failed: ${data.failedReason}`);
    console.log(`  Processing... (${i + 1}/${MAX_POLL_RETRIES})`);
    await sleep(POLL_INTERVAL_MS);
  }
  throw new Error(`Poll timed out after ${MAX_POLL_RETRIES} retries`);
}

export async function publish(apiKey, body) {
  return await api("/content/add", apiKey, body, BASE_URL_V1);
}

export function printPublishSuccess(result) {
  console.log(`\nSuccess!`);
  console.log(`ID: ${result.id ?? "unavailable"}`);
  console.log(`Link: ${result.shareLink ?? "unavailable"}`);
}

export function parseArgs(args, required, optional = []) {
  const result = {};
  for (const flag of [...required, ...optional]) {
    const idx = args.indexOf(`--${flag}`);
    if (idx !== -1 && idx + 1 < args.length) {
      result[flag] = args[idx + 1];
    }
  }
  for (const flag of required) {
    if (!result[flag]) {
      console.error(`Error: --${flag} is required`);
      process.exit(1);
    }
  }
  return result;
}

#!/usr/bin/env node

import { parseArgs, printPublishSuccess, publish, resolveApiKey, uploadImage } from "./lib.mjs";

const args = process.argv.slice(2);

if (args.includes("--help")) {
  console.log(`Usage:
  node post-image.mjs --text <content> --images <paths>
  node post-image.mjs --text <content> --title <title> --cover <path>

Post short image content or an article with a cover image to Binance Square.

Options:
  --text <content> Post text content (required)
  --images <paths> Comma-separated image paths for short posts, max 4
  --title <title>  Article title. When present, publish as contentType=2
  --cover <path>   Cover image path for article posts with --title

Authentication:
  Set BINANCE_SQUARE_OPENAPI_KEY or save a key with scripts/save-key.mjs.`);
  process.exit(0);
}

const { text } = parseArgs(args, ["text"]);
const { title, images, cover } = parseArgs(args, [], ["title", "images", "cover"]);

if (title && images) {
  console.error("Error: article posts with --title use --cover, not --images");
  process.exit(1);
}
if (cover && !title) {
  console.error("Error: --cover requires --title");
  process.exit(1);
}

const imagePaths = title ? [] : images ? images.split(",").map((p) => p.trim()).filter(Boolean) : [];

if (title && !cover) {
  console.error("Error: article posts with --title require --cover <path>");
  process.exit(1);
}
if (title && cover.includes(",")) {
  console.error("Error: article posts support exactly one --cover image");
  process.exit(1);
}
if (!title && imagePaths.length === 0) {
  console.error("Error: --images is required for short image posts");
  process.exit(1);
}
if (imagePaths.length > 4) {
  console.error("Error: max 4 images allowed");
  process.exit(1);
}

const contentType = title ? 2 : 1;

try {
  const key = resolveApiKey(args);

  const body = { contentType, bodyTextOnly: text };
  if (title) {
    const coverUrl = await uploadImage(key, cover);
    body.title = title;
    body.cover = coverUrl;
  } else {
    const uploadedImages = [];
    for (const imgPath of imagePaths) {
      uploadedImages.push(await uploadImage(key, imgPath));
    }
    body.imageList = uploadedImages;
  }

  console.log("Publishing...");
  const result = await publish(key, body);
  printPublishSuccess(result);
} catch (err) {
  console.error(`\nFailed: ${err.message}`);
  process.exit(1);
}

#!/usr/bin/env node

import { parseArgs, printPublishSuccess, publish, resolveApiKey } from "./lib.mjs";

const args = process.argv.slice(2);

if (args.includes("--help")) {
  console.log(`Usage: node post-text.mjs --text <content> [--title <title>]

Post text content to Binance Square as a short post or long article.

Options:
  --text <content> Post text content (required)
  --title <title>  Article title. When present, publish as contentType=2 (optional)

Authentication:
  Set BINANCE_SQUARE_OPENAPI_KEY or save a key with scripts/save-key.mjs.`);
  process.exit(0);
}

const { text } = parseArgs(args, ["text"]);
const { title } = parseArgs(args, [], ["title"]);

const contentType = title ? 2 : 1;

try {
  const key = resolveApiKey(args);

  console.log(contentType === 2 ? "Publishing article..." : "Publishing text post...");
  const body = {
    contentType,
    bodyTextOnly: text,
  };
  if (title) body.title = title;

  const result = await publish(key, body);
  printPublishSuccess(result);
} catch (err) {
  console.error(`\nFailed: ${err.message}`);
  process.exit(1);
}

#!/usr/bin/env node

import fs from "fs";
import os from "os";
import path from "path";
import { spawnSync } from "child_process";
import { parseArgs, api, uploadToS3, pollImageStatus, publish, getContentType, uploadImage, printPublishSuccess, resolveApiKey } from "./lib.mjs";

const args = process.argv.slice(2);

if (args.includes("--help")) {
  console.log(`Usage: node post-video.mjs --video <path> --duration <seconds> [--text <content>]

Post a video to Binance Square.

Options:
  --video <path>       Video file path (required)
  --duration <seconds> Video duration in seconds (required)
  --text <content>     Post text content (optional)

Authentication:
  Set BINANCE_SQUARE_OPENAPI_KEY or save a key with scripts/save-key.mjs.`);
  process.exit(0);
}

const { video, duration } = parseArgs(args, ["video", "duration"]);
const { text } = parseArgs(args, [], ["text"]);

const videoTimeSeconds = Number(duration);
if (isNaN(videoTimeSeconds) || videoTimeSeconds <= 0) {
  console.error("Error: --duration must be a positive number");
  process.exit(1);
}

function extractVideoCover(videoPath) {
  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "square-video-cover-"));
  const coverPath = path.join(tempDir, `${path.parse(videoPath).name}-cover.png`);
  const result = spawnSync("ffmpeg", [
    "-y",
    "-loglevel",
    "error",
    "-i",
    videoPath,
    "-frames:v",
    "1",
    "-q:v",
    "2",
    coverPath,
  ], { encoding: "utf8" });

  if (result.error) {
    throw new Error(`Failed to run ffmpeg: ${result.error.message}`);
  }
  if (result.status !== 0) {
    throw new Error(`Failed to extract video cover: ${result.stderr || "ffmpeg exited with an error"}`);
  }
  if (!fs.existsSync(coverPath) || fs.statSync(coverPath).size === 0) {
    throw new Error("Failed to extract video cover: empty cover file");
  }

  return { coverPath, tempDir };
}

function cleanupCover(coverPath, tempDir) {
  if (coverPath && fs.existsSync(coverPath)) fs.unlinkSync(coverPath);
  if (tempDir && fs.existsSync(tempDir)) fs.rmdirSync(tempDir);
}

let coverPath;
let coverTempDir;

try {
  const key = resolveApiKey(args);

  const fileName = path.basename(video);
  const size = fs.statSync(video).size;
  const contentTypeHeader = getContentType(video);

  console.log(`Uploading video: ${fileName} (${(size / 1024 / 1024).toFixed(1)}MB)`);
  const { presignedUrl, fileTicket } = await api("/video/preSign", key, { fileName, size });

  await uploadToS3(presignedUrl, video, contentTypeHeader);
  console.log(`  Uploaded to S3, polling status...`);

  await pollImageStatus(key, fileTicket);
  console.log(`  Video processed.`);

  console.log("Extracting video cover...");
  ({ coverPath, tempDir: coverTempDir } = extractVideoCover(video));
  const cover = await uploadImage(key, coverPath);

  console.log("Publishing...");
  const body = {
    contentType: 3,
    fileTicket,
    cover,
    videoTimeSeconds,
    isPublish: true,
  };
  if (text) body.bodyTextOnly = text;

  const result = await publish(key, body);

  printPublishSuccess(result);
} catch (err) {
  console.error(`\nFailed: ${err.message}`);
  process.exitCode = 1;
} finally {
  cleanupCover(coverPath, coverTempDir);
}

#!/usr/bin/env node

import { maskApiKey, saveApiKey } from "./lib.mjs";

const args = process.argv.slice(2);

if (args.includes("--help")) {
  console.log(`Usage: BINANCE_SQUARE_OPENAPI_KEY=<apiKey> node scripts/save-key.mjs

Save the Binance Square OpenAPI key to a local user config file with 0600 permissions.

Authentication:
  Read the key from BINANCE_SQUARE_OPENAPI_KEY. Do not pass keys as CLI arguments.`);
  process.exit(0);
}

if (args.length > 0) {
  console.error("Error: do not pass API keys as CLI arguments. Set BINANCE_SQUARE_OPENAPI_KEY instead.");
  process.exit(1);
}

const key = process.env.BINANCE_SQUARE_OPENAPI_KEY?.trim();
if (!key) {
  console.error("Error: BINANCE_SQUARE_OPENAPI_KEY is required.");
  process.exit(1);
}

try {
  const keyFile = saveApiKey(key);
  console.log(`Saved Square OpenAPI key ${maskApiKey(key)} to ${keyFile}`);
} catch (err) {
  console.error(`Failed: ${err.message}`);
  process.exit(1);
}