@posteverywhere/cli 0.1.0 → 0.2.0

package/README.md

@@ -1,27 +1,66 @@
 # @posteverywhere/cli
 
-The PostEverywhere CLI for AI agents — schedule and publish to Instagram, TikTok, YouTube, LinkedIn, Facebook, X, Threads, Pinterest, Bluesky, Telegram and Discord from the command line. Every command outputs structured JSON for agents (Claude, Cursor, OpenClaw, …) to parse.
+Post and schedule to **Instagram, TikTok, YouTube, LinkedIn, Facebook, X, Threads, Pinterest, Bluesky, Telegram and Discord** — all from your terminal. Log in once, connect accounts, publish. Built for humans *and* AI agents (`--json` output for Claude, Cursor, etc.).
 
-## Quick start
+## Install
 
 ```bash
-export POSTEVERYWHERE_API_KEY=pe_live_...   # Settings → Developers in the dashboard
+npm install -g @posteverywhere/cli
+# …or run without installing:
+npx @posteverywhere/cli <command>
+```
+
+## 90-second setup
 
-npx @posteverywhere/cli whoami              # verify the key
-npx @posteverywhere/cli accounts            # list connected accounts (+ ids)
-npx @posteverywhere/cli post -c "Hello 🚀" -a 123,456          # publish now
-npx @posteverywhere/cli post -c "Later" -a 123 -s 2026-07-01T09:00:00Z   # schedule (UTC)
+```bash
+posteverywhere login                 # opens your browser, saves a key to ~/.posteverywhere
+posteverywhere connect instagram     # opens the OAuth flow; auto-detects the connected account
+posteverywhere accounts              # list connected accounts (+ ids & health)
+posteverywhere post -c "Hello 🚀" -a 123,456
 ```
 
-Run `npx @posteverywhere/cli help` for the full command list.
+`login` uses a device-grant flow (like the GitHub CLI): it prints a short code, you approve it in the browser, and a scoped API key is saved locally (`chmod 600`). Manage or revoke it anytime from **Settings → Developers**.
+
+## Connecting accounts
+
+```bash
+posteverywhere connect <platform>
+```
+- **Browser platforms** (`instagram`, `facebook`, `threads`, `x`, `linkedin`, `tiktok`, `youtube`, `pinterest`): opens the normal OAuth flow in your browser, then auto-detects the new account.
+- **Bluesky**: prompts for your handle + an App Password (Settings → App Passwords).
+- **Telegram**: prompts for a bot token (@BotFather) + your channel — add the bot as an admin first.
+- **Discord**: prompts for a channel webhook URL (Server Settings → Integrations → Webhooks).
+
+Re-authorize an expired account: `posteverywhere reconnect <accountId>`.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `login` / `logout` | Device-flow login / remove saved credentials |
+| `whoami` | Show the authed account, plan & quota |
+| `accounts` | List connected accounts (+ ids & health) |
+| `connect <platform>` | Connect a new account |
+| `reconnect <accountId>` | Re-authorize an account whose token expired |
+| `account:health <id>` | Detailed health for one account |
+| `post -c <text> -a <ids> [-s <iso>] [-m <mediaIds>]` | Publish now (omit `-s`) or schedule (`-s` ISO time) |
+| `posts [--status x] [--platform y] [--limit n]` | List posts |
+| `results <postId>` | Per-platform publish results |
+| `retry <postId>` | Retry failed destinations |
+| `upload <imageUrl>` | Import an image by URL → media_id |
+| `caption -t <topic> [--platform x] [--tone y]` | AI captions |
+| `analytics [--period week\|month\|all]` | Analytics summary |
+| `campaigns` | List campaigns |
 
 ## For AI agents
 
-This package ships a `SKILL.md` describing the commands for agent auto-discovery. Point your agent at it, or connect via MCP instead:
+Every command accepts `--json` (auto-on when piped) and emits structured JSON. This package ships a `SKILL.md` for agent auto-discovery — point Claude/Cursor/etc. at it. Prefer MCP? Use the hosted endpoint `https://mcp.posteverywhere.ai/mcp` or `npx -y @posteverywhere/mcp`.
+
+## Auth precedence
 
-- **Hosted MCP (no install):** `https://mcp.posteverywhere.ai` — see [docs](https://developers.posteverywhere.ai/integrations/mcp)
-- **Local MCP:** `npx -y @posteverywhere/mcp`
+1. `POSTEVERYWHERE_API_KEY` env var (great for CI / agents)
+2. the key saved by `posteverywhere login` (`~/.posteverywhere/config.json`)
 
-## Auth & safety
+Your key authenticates into **your** PostEverywhere account and acts only through it — the CLI never touches your social-platform credentials directly. Keep a human in the loop before publishing.
 
-Your API key authenticates into **your PostEverywhere account** and acts only through it — the CLI never touches your social-platform credentials directly. Keep a human in the loop before publishing.
+Docs: https://developers.posteverywhere.ai/cli

package/SKILL.md

@@ -8,15 +8,15 @@ description: Schedule and publish social media posts to Instagram, TikTok, YouTu
 Manage a user's social media through the PostEverywhere CLI. Every command prints JSON.
 
 ## Setup (once)
-The user must set their API key (from posteverywhere.ai → Settings → Developers):
-```bash
-export POSTEVERYWHERE_API_KEY=pe_live_...
-```
+Authenticate one of two ways:
+- **Interactive:** `posteverywhere login` opens the browser; the user approves a short code and a scoped key is saved locally. Then `posteverywhere connect <platform>` to add accounts (instagram, tiktok, youtube, linkedin, facebook, x, threads, pinterest = browser OAuth; bluesky/telegram/discord = the CLI prompts for credentials).
+- **Non-interactive (CI / headless agents):** `export POSTEVERYWHERE_API_KEY=pe_live_...` (from posteverywhere.ai → Settings → Developers).
+
 Run commands with `npx @posteverywhere/cli <command>` (or `posteverywhere <command>` if installed).
 
 ## Always start here
 1. `posteverywhere whoami` — confirms the key works and shows the plan/quota.
-2. `posteverywhere accounts` — lists connected accounts. **You need the numeric account `id`s to post.** If empty, tell the user to connect accounts in the dashboard first.
+2. `posteverywhere accounts` — lists connected accounts. **You need the numeric account `id`s to post.** If empty, run `posteverywhere connect <platform>` (or tell the user to connect in the dashboard).
 
 ## Core workflow
 **Publish now** to accounts 123 and 456:

package/dist/index.js

@@ -1,30 +1,101 @@
 #!/usr/bin/env node
-"use strict";
 /**
- * PostEverywhere CLI for AI agents (task #245, "skill" distribution).
+ * posteverywhere — the PostEverywhere CLI.
  *
- * Thin wrapper over the public v1 REST API. Every command prints structured
- * JSON to stdout so agents (Claude, Cursor, OpenClaw, etc.) can parse results.
- * Auth: set POSTEVERYWHERE_API_KEY=pe_live_... (Settings → Developers).
+ * Log in once (`posteverywhere login`), connect accounts, and post/schedule to
+ * Instagram, TikTok, YouTube, LinkedIn, Facebook, X, Threads, Pinterest,
+ * Bluesky, Telegram & Discord — all from your terminal.
  *
- * Same surface as the MCP server, for agents that run shell commands rather
- * than speak MCP. See SKILL.md for the agent-facing command reference.
+ * Agent-friendly: pass --json (or pipe to a non-TTY) and every command emits
+ * structured JSON so Claude, Cursor, OpenClaw etc. can parse results.
+ *
+ * Auth resolves from (1) POSTEVERYWHERE_API_KEY, else (2) the key saved by
+ * `posteverywhere login` at ~/.posteverywhere/config.json (chmod 600).
+ *
+ * Zero runtime dependencies — pure Node (>=18) so `npx posteverywhere-cli`
+ * is instant and adds no supply-chain surface.
  */
-const BASE = (process.env.POSTEVERYWHERE_API_URL || 'https://app.posteverywhere.ai').replace(/\/$/, '');
-const KEY = process.env.POSTEVERYWHERE_API_KEY || '';
-function out(data) {
-    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
-}
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { spawn } from 'node:child_process';
+const BASE = (process.env.POSTEVERYWHERE_API_URL || process.env.POSTEVERYWHERE_BASE_URL || 'https://app.posteverywhere.ai').replace(/\/$/, '');
+const CONFIG_DIR = path.join(os.homedir(), '.posteverywhere');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const WANT_JSON = process.argv.includes('--json') || !process.stdout.isTTY;
+const TTY = !!process.stdout.isTTY;
+// ─── output ──────────────────────────────────────────────
+const C = { reset: '\x1b[0m', dim: '\x1b[2m', bold: '\x1b[1m', green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', cyan: '\x1b[36m' };
+const paint = (s, code) => (TTY ? `${code}${s}${C.reset}` : s);
+function outJson(data) { process.stdout.write(JSON.stringify(data, null, 2) + '\n'); }
+function say(msg = '') { process.stdout.write(msg + '\n'); }
 function fail(message, code = 1) {
-    process.stderr.write(JSON.stringify({ error: message }) + '\n');
+    if (WANT_JSON)
+        process.stderr.write(JSON.stringify({ error: message }) + '\n');
+    else
+        process.stderr.write(paint('✖ ' + message, C.red) + '\n');
     process.exit(code);
 }
-// Parse "cmd positional --flag value -f value --bool" into { _: [...], flags }.
+function loadConfig() { try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+}
+catch {
+    return {};
+} }
+function saveConfig(cfg) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+        try {
+            fs.chmodSync(CONFIG_PATH, 0o600);
+        }
+        catch { /* best effort on non-POSIX */ }
+    }
+    catch (e) {
+        fail(`Could not save credentials to ${CONFIG_PATH}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function resolveKey() { return process.env.POSTEVERYWHERE_API_KEY || loadConfig().api_key || ''; }
+// ─── http ────────────────────────────────────────────────
+async function raw(method, p, body, key) {
+    const headers = { Accept: 'application/json' };
+    if (key)
+        headers.Authorization = `Bearer ${key}`;
+    if (body)
+        headers['Content-Type'] = 'application/json';
+    let resp;
+    try {
+        resp = await fetch(`${BASE}${p}`, { method, headers, body: body ? JSON.stringify(body) : undefined });
+    }
+    catch (e) {
+        return fail(`Network error reaching ${BASE}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const json = await resp.json().catch(() => ({}));
+    return { status: resp.status, json };
+}
+// Authenticated v1 call — unwraps {data,error}; fails cleanly on error.
+async function api(method, p, body) {
+    const key = resolveKey();
+    if (!key || !key.startsWith('pe_live_')) {
+        fail('Not logged in. Run `posteverywhere login` (or set POSTEVERYWHERE_API_KEY=pe_live_...).');
+    }
+    const { json } = await raw(method, `/api/v1${p}`, body, key);
+    if (json?.error)
+        fail(typeof json.error === 'string' ? json.error : json.error.message || 'API error');
+    return json?.data;
+}
+// ─── small helpers ───────────────────────────────────────
+const csv = (v) => (typeof v === 'string' ? v.split(',').map(s => s.trim()).filter(Boolean) : []);
+const num = (v) => csv(v).map(Number).filter(n => !Number.isNaN(n));
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
+        if (a === '--json')
+            continue;
         if (a.startsWith('--') || a.startsWith('-')) {
             const key = a.replace(/^-+/, '');
             const next = argv[i + 1];
@@ -40,51 +111,247 @@ function parseArgs(argv) {
     }
     return { positional, flags };
 }
-async function api(method, path, body) {
-    if (!KEY || !KEY.startsWith('pe_live_')) {
-        fail('Missing or invalid POSTEVERYWHERE_API_KEY (must start with pe_live_). Create one at ' + BASE + ' → Settings → Developers.');
+function openBrowser(url) {
+    try {
+        const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+        const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+        spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
     }
-    let resp;
+    catch { /* best effort — the URL is always printed too */ }
+}
+function askLine(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+    });
+}
+// Masked secret prompt (app passwords / bot tokens). Standard readline with a
+// muted output stream so the secret is never echoed to the screen; backspace,
+// Enter and Ctrl-C are handled natively by readline. No raw-mode parsing.
+function askSecret(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        let muted = false;
+        const origWrite = typeof rl._writeToOutput === 'function' ? rl._writeToOutput.bind(rl) : null;
+        rl._writeToOutput = (str) => {
+            if (!muted) {
+                origWrite ? origWrite(str) : process.stdout.write(str);
+                return;
+            }
+            // While muted, only let newlines through so Enter still drops the cursor.
+            if (/[\r\n]/.test(str)) {
+                origWrite ? origWrite('\n') : process.stdout.write('\n');
+            }
+        };
+        rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+        muted = true; // everything typed after the prompt is shown is hidden
+    });
+}
+// ─── login (device-grant flow) ───────────────────────────
+async function login() {
+    if (resolveKey() && !process.env.POSTEVERYWHERE_API_KEY) {
+        const who = loadConfig().email;
+        say(paint(`Already logged in${who ? ` as ${who}` : ''}. Run \`posteverywhere logout\` first to switch accounts.`, C.yellow));
+        return;
+    }
+    const start = await raw('POST', '/api/v1/auth/device', { client_name: `CLI on ${os.hostname()}` });
+    if (start.json?.error || !start.json?.data) {
+        fail(typeof start.json?.error === 'string' ? start.json.error : start.json?.error?.message || 'Could not start login.');
+    }
+    const { device_code, user_code, verification_uri, verification_uri_complete, interval } = start.json.data;
+    if (WANT_JSON) {
+        outJson({ status: 'pending', user_code, verification_uri, verification_uri_complete, device_code });
+    }
+    else {
+        say('');
+        say(`  ${paint('Connect this CLI to PostEverywhere', C.bold)}`);
+        say('');
+        say(`  1. Open: ${paint(verification_uri, C.cyan)}`);
+        say(`  2. Enter code: ${paint(user_code, C.bold)}`);
+        say('');
+        say(paint('  Opening your browser…', C.dim));
+        openBrowser(verification_uri_complete);
+        say(paint('  Waiting for you to approve…  (Ctrl-C to cancel)', C.dim));
+    }
+    const pollInterval = Math.max(2, Number(interval) || 5) * 1000;
+    const deadline = Date.now() + 15 * 60 * 1000;
+    let delay = pollInterval;
+    while (Date.now() < deadline) {
+        await sleep(delay);
+        const { json } = await raw('POST', '/api/v1/auth/device/token', { device_code });
+        if (json?.error)
+            fail(typeof json.error === 'string' ? json.error : json.error.message || 'Login failed.');
+        const data = json?.data || {};
+        switch (data.status) {
+            case 'pending': continue;
+            case 'slow_down':
+                delay += 2000;
+                continue;
+            case 'denied': fail('Login was denied in the browser.');
+            case 'expired': fail('The login code expired. Run `posteverywhere login` again.');
+            case 'authorized': {
+                saveConfig({ api_key: data.api_key, email: data.user?.email, organization_id: data.organization_id });
+                if (WANT_JSON)
+                    return outJson({ status: 'authorized', email: data.user?.email, organization_id: data.organization_id });
+                say('');
+                say(paint(`  ✓ Logged in as ${data.user?.email || 'your account'}`, C.green));
+                say(paint(`  Credentials saved to ${CONFIG_PATH}`, C.dim));
+                say('');
+                say('  Next: `posteverywhere accounts` to see connected accounts, or');
+                say('        `posteverywhere connect instagram` to connect one.');
+                return;
+            }
+            default: continue;
+        }
+    }
+    fail('Timed out waiting for approval. Run `posteverywhere login` again.');
+}
+function logout() {
     try {
-        resp = await fetch(`${BASE}/api/v1${path}`, {
-            method,
-            headers: { Authorization: `Bearer ${KEY}`, ...(body ? { 'Content-Type': 'application/json' } : {}) },
-            body: body ? JSON.stringify(body) : undefined,
-        });
+        fs.rmSync(CONFIG_PATH, { force: true });
     }
-    catch (e) {
-        fail(`Network error: ${e instanceof Error ? e.message : String(e)}`);
+    catch { }
+    if (WANT_JSON)
+        return outJson({ ok: true });
+    say(paint('✓ Logged out. Credentials removed.', C.green));
+}
+// ─── account connect / reconnect (browser bridge) ─────────
+const HEADLESS_PLATFORMS = new Set(['bluesky', 'telegram', 'discord']);
+async function connectHeadless(platform) {
+    if (platform === 'bluesky') {
+        say(paint('Connect Bluesky', C.bold));
+        const handle = await askLine('  Handle (e.g. you.bsky.social): ');
+        const appPassword = await askSecret('  App password (Settings → App Passwords): ');
+        if (!handle || !appPassword)
+            fail('Both handle and app password are required.');
+        const data = await api('POST', '/auth/social-connect/bluesky', { handle, app_password: appPassword });
+        if (WANT_JSON)
+            return outJson(data);
+        return say(paint(`✓ Connected Bluesky as ${data?.account?.account_name || handle}`, C.green));
     }
-    const json = await resp.json().catch(() => ({ error: { message: `HTTP ${resp.status}` } }));
-    if (json.error)
-        fail(typeof json.error === 'string' ? json.error : json.error.message || 'API error');
-    return json.data;
+    if (platform === 'telegram') {
+        say(paint('Connect Telegram', C.bold));
+        const botToken = await askSecret('  Bot token (from @BotFather): ');
+        if (!botToken)
+            fail('A bot token is required.');
+        const channel = await askLine('  Channel (e.g. @mychannel, or its numeric id): ');
+        if (!channel)
+            fail('A channel is required — add your bot to it as an admin first.');
+        const data = await api('POST', '/auth/social-connect/telegram', { bot_token: botToken, channel });
+        if (WANT_JSON)
+            return outJson(data);
+        return say(paint(`✓ Connected Telegram (${data?.account?.account_name || 'channel'})`, C.green));
+    }
+    if (platform === 'discord') {
+        say(paint('Connect Discord', C.bold));
+        say(paint('  Discord: Server Settings → Integrations → Webhooks → New Webhook → Copy URL', C.dim));
+        const webhookUrl = await askSecret('  Webhook URL: ');
+        if (!webhookUrl)
+            fail('A Discord webhook URL is required.');
+        const data = await api('POST', '/auth/social-connect/discord', { webhook_url: webhookUrl });
+        if (WANT_JSON)
+            return outJson(data);
+        return say(paint(`✓ Connected Discord (${data?.account?.account_name || 'channel'})`, C.green));
+    }
+}
+async function connectBrowser(platform, opts = {}) {
+    const body = { platform };
+    if (opts.mode)
+        body.mode = opts.mode;
+    if (opts.account_id)
+        body.account_id = opts.account_id;
+    const { session_id, authorize_url, interval } = await api('POST', '/auth/social-connect/start', body);
+    if (WANT_JSON) {
+        outJson({ status: 'pending', session_id, authorize_url });
+    }
+    else {
+        const verb = opts.mode === 'reconnect' ? 'Reconnect' : 'Connect';
+        say('');
+        say(`  ${paint(`${verb} ${platform}`, C.bold)}`);
+        say(`  Open: ${paint(authorize_url, C.cyan)}`);
+        say(paint('  Opening your browser…', C.dim));
+        openBrowser(authorize_url);
+        say(paint('  Waiting for you to finish in the browser…  (Ctrl-C to cancel)', C.dim));
+    }
+    const pollInterval = Math.max(2, Number(interval) || 3) * 1000;
+    const deadline = Date.now() + 15 * 60 * 1000;
+    while (Date.now() < deadline) {
+        await sleep(pollInterval);
+        const data = await api('GET', `/auth/social-connect/poll/${session_id}`);
+        if (data.status === 'pending')
+            continue;
+        if (data.status === 'expired')
+            fail('The connection link expired. Try again.');
+        if (data.status === 'cancelled')
+            fail('Connection was cancelled.');
+        if (data.status === 'completed') {
+            if (WANT_JSON)
+                return outJson(data);
+            const a = data.account || {};
+            say('');
+            say(paint(`  ✓ ${opts.mode === 'reconnect' ? 'Reconnected' : 'Connected'} ${a.platform || platform}${a.account_name ? ` as ${a.account_name}` : ''}`, C.green));
+            return;
+        }
+    }
+    fail('Timed out. Try again.');
+}
+async function connect(platform) {
+    if (!platform)
+        fail('Usage: posteverywhere connect <platform>  (e.g. instagram, tiktok, bluesky, telegram)');
+    const p = platform.toLowerCase();
+    if (HEADLESS_PLATFORMS.has(p))
+        return connectHeadless(p);
+    return connectBrowser(p);
+}
+async function reconnect(arg) {
+    if (!arg)
+        fail('Usage: posteverywhere reconnect <accountId>  (run `posteverywhere accounts` to find ids)');
+    const accountId = Number(arg);
+    if (Number.isNaN(accountId))
+        fail('Provide a numeric account id (from `posteverywhere accounts`).');
+    const acct = await api('GET', `/accounts/${accountId}`).catch(() => null);
+    const platform = acct?.platform;
+    if (!platform)
+        fail(`Could not find account ${accountId}. Run \`posteverywhere accounts\`.`);
+    if (HEADLESS_PLATFORMS.has(String(platform).toLowerCase()))
+        return connectHeadless(String(platform).toLowerCase());
+    return connectBrowser(String(platform).toLowerCase(), { mode: 'reconnect', account_id: accountId });
 }
-const csv = (v) => (typeof v === 'string' ? v.split(',').map((s) => s.trim()).filter(Boolean) : []);
-const num = (v) => csv(v).map(Number).filter((n) => !Number.isNaN(n));
-const HELP = `PostEverywhere CLI — manage social media from the command line / AI agents.
+// ─── help ────────────────────────────────────────────────
+const HELP = `${paint('posteverywhere', C.bold)} — post & schedule to every social platform from your terminal.
 
-Auth:  export POSTEVERYWHERE_API_KEY=pe_live_...   (Settings → Developers)
+${paint('Getting started', C.bold)}
+  posteverywhere login              Log in (opens your browser, saves a key locally)
+  posteverywhere connect <platform> Connect an account (instagram, tiktok, youtube,
+                                    linkedin, facebook, x, threads, pinterest,
+                                    bluesky, telegram, discord)
+  posteverywhere accounts           List connected accounts (+ ids & health)
+  posteverywhere post -c "Hello" -a 123,456
 
-Commands:
-  whoami                         Show the authed account, quota, and scopes
-  accounts                       List connected social accounts (+ their ids/health)
+${paint('Commands', C.bold)}
+  login                          Device-flow login (browser approval)
+  logout                         Remove saved credentials
+  whoami                         Show the authed account, plan & quota
+  accounts                       List connected social accounts
+  connect <platform>             Connect a new account
+  reconnect <accountId>          Re-authorize an account whose token expired
   account:health <id>            Detailed health for one account
-  post -c <text> -a <ids> [-s <iso>] [-m <media_ids>]
-                                 Create/schedule a post (-a = comma account ids; omit -s = publish now)
-  posts [--status x] [--platform y] [--limit n]
-                                 List posts
-  results <postId>               Per-platform publish results for a post
-  retry <postId>                 Retry failed destinations of a post
-  upload <imageUrl>              Import an image by URL (one-call), returns media_id
-  caption -t <topic> [--platform x] [--tone y]
-                                 Generate AI captions
-  analytics [--period week|month|all]
-                                 Account analytics summary
+  post -c <text> -a <ids> [-s <iso>] [-m <mediaIds>]
+                                 Publish now (omit -s) or schedule (-s ISO time)
+  posts [--status x] [--platform y] [--limit n]    List posts
+  results <postId>               Per-platform publish results
+  retry <postId>                 Retry failed destinations
+  upload <imageUrl>              Import an image by URL -> media_id
+  caption -t <topic> [--platform x] [--tone y]     AI captions
+  analytics [--period week|month|all]              Analytics summary
   campaigns                      List campaigns
 
-All output is JSON on stdout. Errors are JSON on stderr with a non-zero exit.
-Docs: https://developers.posteverywhere.ai/integrations/mcp`;
+${paint('Flags', C.bold)}
+  --json     Machine-readable JSON output (auto-on when piped). Great for agents.
+
+Auth precedence: POSTEVERYWHERE_API_KEY env var, else the key from \`login\`.
+Docs: https://developers.posteverywhere.ai`;
+// ─── main ────────────────────────────────────────────────
 async function main() {
     const [, , cmd, ...rest] = process.argv;
     const { positional, flags } = parseArgs(rest);
@@ -94,17 +361,17 @@ async function main() {
         case 'help':
         case '--help':
         case '-h':
-            process.stdout.write(HELP + '\n');
-            return;
-        case 'whoami':
-            return out(await api('GET', '/me'));
-        case 'accounts':
-            return out(await api('GET', '/accounts'));
+            return say(HELP);
+        case 'login': return login();
+        case 'logout': return logout();
+        case 'whoami': return outJson(await api('GET', '/me'));
+        case 'accounts': return outJson(await api('GET', '/accounts'));
+        case 'connect': return connect(positional[0]);
+        case 'reconnect': return reconnect(positional[0]);
         case 'account:health': {
-            const id = positional[0];
-            if (!id)
+            if (!positional[0])
                 fail('Usage: posteverywhere account:health <accountId>');
-            return out(await api('GET', `/accounts/${id}/health`));
+            return outJson(await api('GET', `/accounts/${positional[0]}/health`));
         }
         case 'post': {
             const content = f('content', 'c');
@@ -122,7 +389,10 @@ async function main() {
             const media = csv(f('media', 'm'));
             if (media.length)
                 body.media_ids = media;
-            return out(await api('POST', '/posts', body));
+            const data = await api('POST', '/posts', body);
+            if (!WANT_JSON)
+                say(paint(`✓ ${body.scheduled_for ? 'Scheduled' : 'Publishing'} to ${accounts.length} account(s).`, C.green));
+            return outJson(data);
         }
         case 'posts': {
             const q = new URLSearchParams();
@@ -131,23 +401,21 @@ async function main() {
             if (typeof f('platform') === 'string')
                 q.set('platform', f('platform'));
             q.set('limit', String(f('limit') || 20));
-            return out(await api('GET', `/posts?${q.toString()}`));
+            return outJson(await api('GET', `/posts?${q.toString()}`));
         }
-        case 'results': {
+        case 'results':
             if (!positional[0])
                 fail('Usage: posteverywhere results <postId>');
-            return out(await api('GET', `/posts/${positional[0]}/results`));
-        }
-        case 'retry': {
+            return outJson(await api('GET', `/posts/${positional[0]}/results`));
+        case 'retry':
             if (!positional[0])
                 fail('Usage: posteverywhere retry <postId>');
-            return out(await api('POST', `/posts/${positional[0]}/retry`));
-        }
+            return outJson(await api('POST', `/posts/${positional[0]}/retry`));
         case 'upload': {
             const url = positional[0] || f('url');
             if (typeof url !== 'string')
                 fail('Usage: posteverywhere upload <imageUrl>');
-            return out(await api('POST', '/media/upload-from-url', { url }));
+            return outJson(await api('POST', '/media/upload-from-url', { url }));
         }
         case 'caption': {
             const topic = f('topic', 't');
@@ -158,16 +426,14 @@ async function main() {
                 body.platform = f('platform');
             if (typeof f('tone') === 'string')
                 body.tone = f('tone');
-            return out(await api('POST', '/ai/generate-caption', body));
-        }
-        case 'analytics': {
-            const period = f('period') || 'month';
-            return out(await api('GET', `/analytics/summary?period=${encodeURIComponent(period)}`));
+            return outJson(await api('POST', '/ai/generate-caption', body));
         }
+        case 'analytics':
+            return outJson(await api('GET', `/analytics/summary?period=${encodeURIComponent(f('period') || 'month')}`));
         case 'campaigns':
-            return out(await api('GET', '/campaigns'));
+            return outJson(await api('GET', '/campaigns'));
         default:
-            fail(`Unknown command: ${cmd}. Run \`posteverywhere help\` for the command list.`);
+            fail(`Unknown command: ${cmd}. Run \`posteverywhere help\`.`);
     }
 }
 main().catch((e) => fail(e instanceof Error ? e.message : String(e)));

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "@posteverywhere/cli",
-  "version": "0.1.0",
-  "description": "PostEverywhere CLI for AI agents — schedule and publish to Instagram, TikTok, YouTube, LinkedIn, Facebook, X, Threads, Pinterest, Bluesky, Telegram & Discord from the command line. Structured JSON output for Claude, Cursor, and other agents.",
+  "version": "0.2.0",
+  "description": "Post and schedule to Instagram, TikTok, YouTube, LinkedIn, Facebook, X, Threads, Pinterest, Bluesky, Telegram & Discord from your terminal. Log in once, connect accounts, publish. Also works as a tool for Claude, Cursor and other AI agents (--json output).",
   "type": "module",
   "bin": {
-    "posteverywhere": "dist/index.js"
+    "posteverywhere": "dist/index.js",
+    "posteverywhere-cli": "dist/index.js"
   },
   "files": ["dist", "SKILL.md", "README.md"],
+  "publishConfig": { "access": "public" },
   "engines": { "node": ">=18.0.0" },
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["social media", "cli", "ai agent", "claude", "mcp", "scheduling", "automation"],
+  "keywords": [
+    "social media", "cli", "scheduling", "instagram", "tiktok", "youtube",
+    "linkedin", "bluesky", "ai agent", "claude", "mcp", "automation", "posteverywhere"
+  ],
   "license": "MIT",
+  "homepage": "https://posteverywhere.ai",
+  "bugs": { "url": "https://posteverywhere.ai" },
   "devDependencies": { "typescript": "^5.6.0", "@types/node": "^20.0.0" }
 }