@posthero/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 a007mr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/posthero.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../src/index.js');

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@posthero/cli",
+  "version": "0.1.0",
+  "description": "PostHero CLI — create, schedule, and publish social media posts from the terminal",
+  "license": "MIT",
+  "author": "PostHero",
+  "homepage": "https://posthero.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a007mr/posthero-cli.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "posthero": "./bin/posthero.js"
+  },
+  "main": "./src/index.js",
+  "files": [
+    "bin",
+    "src",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "node bin/posthero.js"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "conf": "^10.2.0",
+    "form-data": "^4.0.1",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const axios = require('axios');
+const { getConfig } = require('./config');
+
+function resolveApiKey(cmdOptions = {}) {
+  return cmdOptions.key || process.env.POSTHERO_API_KEY || getConfig().apiKey;
+}
+
+function createClient(cmdOptions = {}) {
+  const key = resolveApiKey(cmdOptions);
+
+  if (!key) {
+    const chalk = require('chalk');
+    console.error(chalk.red('No API key found. Run: posthero login'));
+    process.exit(1);
+  }
+
+  const { baseUrl } = getConfig();
+
+  return axios.create({
+    baseURL: baseUrl,
+    headers: {
+      Authorization: `Bearer ${key}`,
+      'Content-Type': 'application/json',
+    },
+  });
+}
+
+async function apiCall(fn) {
+  try {
+    const res = await fn();
+    return res.data;
+  } catch (err) {
+    const data = err.response?.data;
+    const msg = data?.error || err.message;
+    const code = data?.code || 'UNKNOWN';
+    const chalk = require('chalk');
+    console.error(chalk.red(`Error [${code}]: ${msg}`));
+    process.exit(1);
+  }
+}
+
+module.exports = { createClient, apiCall, resolveApiKey };

package/src/commands/accounts.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const chalk = require('chalk');
+const { createClient, apiCall } = require('../api');
+const { isJsonMode, printJson, printTable } = require('../output');
+
+async function list(options) {
+  const client = createClient(options);
+  const result = await apiCall(() => client.get('/accounts'));
+
+  if (isJsonMode(options)) {
+    printJson(result.data);
+    return;
+  }
+
+  if (!result.data.length) {
+    console.log(chalk.grey('No connected accounts found.'));
+    return;
+  }
+
+  printTable(
+    ['ID', 'Platform', 'Name', 'Username', 'Type'],
+    result.data.map(a => [
+      chalk.grey(String(a.id)),
+      chalk.bold(a.platform),
+      a.name || '—',
+      a.username ? '@' + a.username : '—',
+      a.type || '—',
+    ])
+  );
+}
+
+module.exports = { list };

package/src/commands/login.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const inquirer = require('inquirer');
+const ora = require('ora');
+const chalk = require('chalk');
+const { setApiKey, clearApiKey } = require('../config');
+const { createClient, apiCall } = require('../api');
+const { maskKey } = require('../output');
+
+async function login(options) {
+  let key = options.key;
+
+  if (!key) {
+    const { inputKey } = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'inputKey',
+        message: 'Paste your API key (from posthero.ai/app/settings/api):',
+        validate: v => v.startsWith('pk_') ? true : 'Key must start with pk_',
+      },
+    ]);
+    key = inputKey;
+  }
+
+  const spinner = ora('Validating API key...').start();
+
+  try {
+    const client = createClient({ key });
+    const result = await apiCall(() => client.get('/accounts'));
+
+    if (result.success) {
+      setApiKey(key);
+      spinner.succeed(`Logged in! Key saved: ${maskKey(key)}`);
+      console.log(chalk.grey(`  Found ${result.data.length} connected account(s).`));
+    } else {
+      spinner.fail('Invalid API key.');
+      process.exit(1);
+    }
+  } catch {
+    spinner.fail('Could not validate key.');
+    process.exit(1);
+  }
+}
+
+function logout() {
+  clearApiKey();
+  console.log(chalk.green('✓') + ' Logged out. API key removed.');
+}
+
+async function whoami(options) {
+  const { createClient, apiCall, resolveApiKey } = require('../api');
+  const { maskKey } = require('../output');
+
+  const key = resolveApiKey(options);
+  if (!key) {
+    console.error(chalk.red('Not logged in. Run: posthero login'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Fetching info...').start();
+  const client = createClient(options);
+
+  const result = await apiCall(() => client.get('/accounts'));
+  spinner.stop();
+
+  console.log('');
+  console.log(`  API Key:  ${maskKey(key)}`);
+  console.log(`  Accounts: ${result.data.length} connected`);
+  console.log('');
+}
+
+module.exports = { login, logout, whoami };

package/src/commands/media.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ora = require('ora');
+const FormData = require('form-data');
+const { createClient, resolveApiKey, apiCall } = require('../api');
+const { getConfig } = require('../config');
+const { isJsonMode, printJson, printSuccess } = require('../output');
+
+// Returns the S3 URL — used internally by posts.js too
+async function upload(filePath, options = {}) {
+  const resolved = path.resolve(filePath);
+
+  if (!fs.existsSync(resolved)) {
+    const chalk = require('chalk');
+    console.error(chalk.red(`File not found: ${resolved}`));
+    process.exit(1);
+  }
+
+  const key = resolveApiKey(options);
+  const { baseUrl } = getConfig();
+
+  const form = new FormData();
+  form.append('file', fs.createReadStream(resolved));
+
+  const spinner = ora(`Uploading ${path.basename(resolved)}...`).start();
+
+  try {
+    const axios = require('axios');
+    const res = await axios.post(`${baseUrl}/media/upload`, form, {
+      headers: {
+        Authorization: `Bearer ${key}`,
+        ...form.getHeaders(),
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+    });
+
+    spinner.stop();
+    return res.data?.data?.url;
+  } catch (err) {
+    spinner.fail('Upload failed.');
+    const chalk = require('chalk');
+    const msg = err.response?.data?.error || err.message;
+    console.error(chalk.red(msg));
+    process.exit(1);
+  }
+}
+
+async function uploadCommand(filePath, options) {
+  const url = await upload(filePath, options);
+
+  if (isJsonMode(options)) {
+    printJson({ url });
+    return;
+  }
+
+  printSuccess(`Uploaded: ${url}`);
+}
+
+module.exports = { upload, uploadCommand };

package/src/commands/posts.js

@@ -0,0 +1,285 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const chalk = require('chalk');
+const { createClient, apiCall } = require('../api');
+const { isJsonMode, printJson, printTable, printSuccess, formatDate } = require('../output');
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function statusColor(status) {
+  switch (status) {
+    case 'published': return chalk.green(status);
+    case 'scheduled': return chalk.yellow(status);
+    case 'draft':     return chalk.grey(status);
+    case 'failed':    return chalk.red(status);
+    default:          return status;
+  }
+}
+
+// Build the POST /posts request body from CLI options + optionally a media URL
+function buildPostBody(options, mediaUrl) {
+  let text = options.text || '';
+
+  if (options.file) {
+    text = fs.readFileSync(path.resolve(options.file), 'utf-8').trim();
+  }
+
+  // Parse platforms string e.g. "linkedin,twitter" → array
+  // Each entry needs platform + accountId.
+  // User can pass: "linkedin:accountId123,twitter:accountId456"
+  // or just "linkedin,twitter" (server resolves first matching account per platform)
+  const parsedPlatforms = (options.platforms || '').split(',').filter(Boolean).map(p => {
+    const [platform, accountId] = p.trim().split(':');
+    return accountId ? { platform, accountId } : { platform };
+  });
+
+  // Per-platform text overrides
+  const platformContent = {};
+  if (options.linkedinText) platformContent.linkedin = { text: options.linkedinText };
+  if (options.twitterText)  platformContent.twitter  = { text: options.twitterText };
+  if (options.blueskyText)  platformContent.bluesky  = { text: options.blueskyText };
+  if (options.threadsText)  platformContent.threads  = { text: options.threadsText };
+
+  const body = {
+    text,
+    platforms: parsedPlatforms,
+    publishNow: options.now || false,
+    schedule: options.schedule || undefined,
+    isThread: options.thread || false,
+  };
+
+  if (Object.keys(platformContent).length) body.platformContent = platformContent;
+
+  if (mediaUrl) {
+    body.media = { images: [mediaUrl] };
+  } else if (options.video) {
+    // video handled separately via upload first
+  }
+
+  return body;
+}
+
+// ── commands ─────────────────────────────────────────────────────────────────
+
+async function list(options) {
+  const client = createClient(options);
+
+  const params = {};
+  if (options.status)   params.status   = options.status;
+  if (options.platform) params.platform = options.platform;
+  if (options.page)     params.page     = options.page;
+  if (options.limit)    params.limit    = options.limit;
+
+  const result = await apiCall(() => client.get('/posts', { params }));
+
+  if (isJsonMode(options)) {
+    printJson(result.data);
+    return;
+  }
+
+  const { posts, pagination } = result.data;
+
+  if (!posts.length) {
+    console.log(chalk.grey('No posts found.'));
+    return;
+  }
+
+  printTable(
+    ['ID', 'Status', 'Platforms', 'Scheduled At', 'Created At'],
+    posts.map(p => [
+      chalk.grey(p.id),
+      statusColor(p.status),
+      (p.platforms || []).map(x => x.platform).join(', ') || '—',
+      formatDate(p.schedule),
+      formatDate(p.createdAt),
+    ])
+  );
+
+  if (pagination) {
+    console.log(chalk.grey(`\n  Page ${pagination.page} of ${Math.ceil(pagination.total / pagination.limit)} — ${pagination.total} total posts`));
+  }
+}
+
+async function get(id, options) {
+  const client = createClient(options);
+  const result = await apiCall(() => client.get(`/posts/${id}`));
+
+  if (isJsonMode(options)) {
+    printJson(result.data);
+    return;
+  }
+
+  const p = result.data;
+  console.log('');
+  console.log(`  ID:        ${chalk.grey(p.id)}`);
+  console.log(`  Status:    ${statusColor(p.status)}`);
+  console.log(`  Text:      ${p.text?.slice(0, 120)}${p.text?.length > 120 ? '…' : ''}`);
+  console.log(`  Platforms: ${(p.platforms || []).map(x => x.platform).join(', ') || '—'}`);
+  console.log(`  Scheduled: ${formatDate(p.schedule)}`);
+  console.log(`  Created:   ${formatDate(p.createdAt)}`);
+
+  if (p.platforms?.length) {
+    console.log('');
+    p.platforms.forEach(x => {
+      const url = x.postUrl ? chalk.cyan(x.postUrl) : '—';
+      console.log(`  [${x.platform}] ${statusColor(x.status)}  ${url}`);
+    });
+  }
+  console.log('');
+}
+
+async function create(options) {
+  let finalOptions = { ...options };
+
+  // Interactive mode when no text and no file
+  if (!options.text && !options.file && !options.interactive) {
+    const client = createClient(options);
+    const accountsResult = await apiCall(() => client.get('/accounts'));
+    const accountChoices = accountsResult.data.map(a => ({
+      name: `${a.platform} — ${a.name || a.username || a.id}`,
+      value: `${a.platform}:${a.id}`,
+    }));
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'editor',
+        name: 'text',
+        message: 'Post content:',
+      },
+      {
+        type: 'checkbox',
+        name: 'platformsList',
+        message: 'Publish to:',
+        choices: accountChoices,
+        validate: v => v.length ? true : 'Select at least one platform',
+      },
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What to do:',
+        choices: [
+          { name: 'Save as draft', value: 'draft' },
+          { name: 'Publish now', value: 'now' },
+          { name: 'Schedule for later', value: 'schedule' },
+        ],
+      },
+      {
+        type: 'input',
+        name: 'schedule',
+        message: 'Schedule time (ISO 8601, e.g. 2025-04-01T09:00:00Z):',
+        when: a => a.action === 'schedule',
+      },
+    ]);
+
+    finalOptions.text = answers.text.trim();
+    finalOptions.platforms = answers.platformsList.join(',');
+    finalOptions.now = answers.action === 'now';
+    finalOptions.schedule = answers.schedule || undefined;
+  }
+
+  // Upload image first if --image flag provided
+  let mediaUrl;
+  if (finalOptions.image) {
+    const { upload } = require('./media');
+    mediaUrl = await upload(finalOptions.image, finalOptions);
+  }
+
+  const body = buildPostBody(finalOptions, mediaUrl);
+
+  if (!body.text && !body.platformContent) {
+    console.error(chalk.red('Post text is required (--text or --file)'));
+    process.exit(1);
+  }
+
+  if (!body.platforms.length) {
+    console.error(chalk.red('At least one platform is required (--platforms linkedin,twitter)'));
+    process.exit(1);
+  }
+
+  const spinner = ora('Creating post...').start();
+  const client = createClient(finalOptions);
+  const result = await apiCall(() => client.post('/posts', body));
+  spinner.stop();
+
+  if (isJsonMode(options)) {
+    printJson(result.data);
+    return;
+  }
+
+  printSuccess(`Post ${result.data.status}: ${chalk.grey(result.data.id)}`);
+  if (result.data.schedule) {
+    console.log(chalk.grey(`  Scheduled for: ${formatDate(result.data.schedule)}`));
+  }
+}
+
+async function update(id, options) {
+  const body = {};
+  if (options.text)     body.text     = options.text;
+  if (options.schedule) body.schedule = options.schedule;
+  if (options.platforms) {
+    body.platforms = options.platforms.split(',').filter(Boolean).map(p => {
+      const [platform, accountId] = p.trim().split(':');
+      return accountId ? { platform, accountId } : { platform };
+    });
+  }
+
+  const spinner = ora('Updating post...').start();
+  const client = createClient(options);
+  const result = await apiCall(() => client.patch(`/posts/${id}`, body));
+  spinner.stop();
+
+  if (isJsonMode(options)) {
+    printJson(result.data);
+    return;
+  }
+
+  printSuccess(`Post updated: ${chalk.grey(id)}`);
+}
+
+async function del(id, options) {
+  if (!options.force) {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Delete post ${id}?`,
+        default: false,
+      },
+    ]);
+    if (!confirm) {
+      console.log(chalk.grey('Cancelled.'));
+      return;
+    }
+  }
+
+  const spinner = ora('Deleting...').start();
+  const client = createClient(options);
+  await apiCall(() => client.delete(`/posts/${id}`));
+  spinner.stop();
+
+  printSuccess(`Post deleted: ${chalk.grey(id)}`);
+}
+
+async function publish(id, options) {
+  const spinner = ora('Publishing...').start();
+  const client = createClient(options);
+  const result = await apiCall(() => client.post(`/posts/${id}/publish`));
+  spinner.stop();
+
+  if (isJsonMode(options)) {
+    printJson(result.data);
+    return;
+  }
+
+  printSuccess(`Published: ${chalk.grey(id)}`);
+  (result.data.results || []).forEach(r => {
+    const url = r.postUrl ? chalk.cyan(r.postUrl) : '';
+    console.log(`  [${r.platform}] ${statusColor(r.status)}  ${url}`);
+  });
+}
+
+module.exports = { list, get, create, update, delete: del, publish };

package/src/config.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Conf = require('conf');
+
+const store = new Conf({
+  projectName: 'posthero',
+  schema: {
+    apiKey: { type: 'string' },
+    baseUrl: { type: 'string' },
+  },
+});
+
+function getConfig() {
+  return {
+    apiKey: store.get('apiKey'),
+    baseUrl: process.env.POSTHERO_BASE_URL || store.get('baseUrl') || 'https://server.posthero.ai/api/v1',
+  };
+}
+
+function setApiKey(key) {
+  store.set('apiKey', key);
+}
+
+function clearApiKey() {
+  store.delete('apiKey');
+}
+
+module.exports = { getConfig, setApiKey, clearApiKey };

package/src/index.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { Command } = require('commander');
+const pkg = require('../package.json');
+
+const loginCmd  = require('./commands/login');
+const accountsCmd = require('./commands/accounts');
+const postsCmd  = require('./commands/posts');
+const mediaCmd  = require('./commands/media');
+
+const program = new Command();
+
+program
+  .name('posthero')
+  .description('PostHero CLI — create, schedule, and publish social media posts from the terminal')
+  .version(pkg.version);
+
+// Global options available on all commands
+const globalOptions = cmd => cmd
+  .option('--key <key>', 'API key (overrides stored key and POSTHERO_API_KEY env var)')
+  .option('--json', 'Output raw JSON (for scripting)');
+
+// ── auth ─────────────────────────────────────────────────────────────────────
+
+program
+  .command('login')
+  .description('Save your API key locally')
+  .option('--key <key>', 'API key to save (non-interactive)')
+  .option('--json', 'Output raw JSON (for scripting)')
+  .action(opts => loginCmd.login(opts));
+
+program
+  .command('logout')
+  .description('Remove stored API key')
+  .action(() => loginCmd.logout());
+
+globalOptions(
+  program
+    .command('whoami')
+    .description('Show current API key and account info')
+).action(opts => loginCmd.whoami(opts));
+
+// ── accounts ─────────────────────────────────────────────────────────────────
+
+const accounts = program.command('accounts').description('Manage connected social media accounts');
+
+globalOptions(
+  accounts
+    .command('list')
+    .description('List all connected accounts')
+).action(opts => accountsCmd.list(opts));
+
+// ── posts ─────────────────────────────────────────────────────────────────────
+
+const posts = program.command('posts').description('Create and manage posts');
+
+globalOptions(
+  posts
+    .command('list')
+    .description('List posts')
+    .option('--status <status>', 'Filter by status: draft | scheduled | published | failed')
+    .option('--platform <platform>', 'Filter by platform')
+    .option('--page <n>', 'Page number', '1')
+    .option('--limit <n>', 'Posts per page', '20')
+).action(opts => postsCmd.list(opts));
+
+globalOptions(
+  posts
+    .command('get <id>')
+    .description('Get a single post by ID')
+).action((id, opts) => postsCmd.get(id, opts));
+
+globalOptions(
+  posts
+    .command('create')
+    .description('Create a post (interactive if no flags given)')
+    .option('--text <text>', 'Post text')
+    .option('--file <path>', 'Read post text from a file (markdown or plain text)')
+    .option('--platforms <list>', 'Comma-separated platforms, e.g. linkedin:id123,twitter:id456')
+    .option('--schedule <iso>', 'Schedule time in ISO 8601 UTC, e.g. 2025-04-01T09:00:00Z')
+    .option('--now', 'Publish immediately')
+    .option('--thread', 'Thread mode (split text on double line breaks)')
+    .option('--image <path>', 'Image file to attach')
+    .option('--linkedin-text <text>', 'LinkedIn-specific text override')
+    .option('--twitter-text <text>', 'Twitter-specific text override')
+    .option('--bluesky-text <text>', 'Bluesky-specific text override')
+    .option('--threads-text <text>', 'Threads-specific text override')
+).action(opts => postsCmd.create(opts));
+
+globalOptions(
+  posts
+    .command('update <id>')
+    .description('Update a draft or scheduled post')
+    .option('--text <text>', 'New text')
+    .option('--schedule <iso>', 'New schedule time')
+    .option('--platforms <list>', 'New platforms list')
+).action((id, opts) => postsCmd.update(id, opts));
+
+globalOptions(
+  posts
+    .command('delete <id>')
+    .description('Delete a post')
+    .option('--force', 'Skip confirmation prompt')
+).action((id, opts) => postsCmd.delete(id, opts));
+
+globalOptions(
+  posts
+    .command('publish <id>')
+    .description('Publish a draft or scheduled post immediately')
+).action((id, opts) => postsCmd.publish(id, opts));
+
+// ── media ─────────────────────────────────────────────────────────────────────
+
+const media = program.command('media').description('Upload media files');
+
+globalOptions(
+  media
+    .command('upload <file>')
+    .description('Upload an image, video, or PDF and get back an S3 URL')
+).action((file, opts) => mediaCmd.uploadCommand(file, opts));
+
+// ── parse ─────────────────────────────────────────────────────────────────────
+
+program.parse(process.argv);

package/src/output.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const chalk = require('chalk');
+const Table = require('cli-table3');
+
+function isJsonMode(options = {}) {
+  return options.json === true;
+}
+
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function printTable(head, rows) {
+  const table = new Table({
+    head: head.map(h => chalk.cyan(h)),
+    style: { border: ['grey'] },
+  });
+  rows.forEach(r => table.push(r));
+  console.log(table.toString());
+}
+
+function printSuccess(msg) {
+  console.log(chalk.green('✓') + ' ' + msg);
+}
+
+function printInfo(msg) {
+  console.log(chalk.grey(msg));
+}
+
+function maskKey(key) {
+  if (!key || key.length < 12) return key;
+  return key.slice(0, 10) + '●'.repeat(8);
+}
+
+function formatDate(dateStr) {
+  if (!dateStr) return chalk.grey('—');
+  return new Date(dateStr).toLocaleString('en-US', {
+    month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit',
+  });
+}
+
+module.exports = { isJsonMode, printJson, printTable, printSuccess, printInfo, maskKey, formatDate };