parley-live 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parley
+
+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/README.md

@@ -0,0 +1,77 @@
+# parley
+
+Generate images, video clips, YouTube thumbnails and spokesperson product ads from the terminal with [Parley](https://labs.parley.live). Built for coding agents as much as people: every command has a `--json` mode, exits with a meaningful code, and never asks a question mid-run.
+
+```bash
+npm install -g parley-live
+parley login                     # one browser sign-in, stored under ~/.parley
+parley account                   # your credit balance
+parley image "a matte black espresso machine on marble, morning light" --out hero.png
+parley video "steam rises, slow push in" --image hero.png --look standard --move dolly-in --ratio 9:16
+parley thumbnail "I tested every AI video tool" --overlay "ALL OF THEM" --variants 3
+parley ugc-ad --product product.jpg --name "Cold Brew Kit" --actor jordan --marketplace amazon
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `parley login` | Device-code sign-in. Prints a link, you sign in once in the browser, the CLI receives a session token. |
+| `parley account` | Credit balance. |
+| `parley engines` | Which video engines this server can run right now, with credit rates. |
+| `parley camera-moves` | The named camera-move presets accepted by `video --move`. |
+| `parley image "<prompt>"` | Generate an image. `--model`, `--size`, `--quality`, `--image-size`, `--ref <file\|url>` (repeatable), `--out`. |
+| `parley video "<motion prompt>"` | Animate a still (`--image`) or text-to-video (`--look photoreal`). `--look`, `--move` (repeatable, up to 3), `--duration`, `--ratio`, `--out`. |
+| `parley thumbnail "<title>"` | 1-3 YouTube thumbnail variants. `--overlay`, `--accent`, `--person`, `--out <dir>`. |
+| `parley ugc-ad` | Product photo → spokesperson ad with a marketplace CTA end-card. `--product`, `--name`, `--actor` or `--face`, `--angle`, `--marketplace`, `--points`, `--seconds`, `--url`, `--out`. |
+| `parley youtube` | A complete faceless video from ordered beat stills: animated per beat, cut to `--narration` with crossfades, `--music` ducked, `--captions` burned in. `--beat` (repeatable, hosted https URLs), `--tier fast\|standard\|cinematic`, `--silent`, `--project`, `--out`. |
+| `parley api <METHOD> </path>` | A signed raw call to any Parley endpoint, JSON in (`--data '{…}'` or `--data @file.json`), JSON out. This is how the Studio (projects, characters, shots, renders, reels) is driven. |
+| `parley whoami`, `parley logout` | Session management. |
+
+### Video looks
+
+| `--look` | Engine | Use for |
+|---|---|---|
+| `fast` | Hailuo 02 | cheapest drafts and B-roll |
+| `standard` | Kling image-to-video | the default: animates the exact still, keeps its style |
+| `cinematic` | Veo 3.1 | hero and establishing shots |
+| `photoreal` | Seedance 2.0 | text-to-video with no still |
+| `transform` | Gemini Omni Flash | change the picture while animating it (native audio) |
+| `camera` | Higgsfield DoP | named camera moves as real motion parameters; falls back to `standard` with the moves as camera direction when the engine is not enabled |
+
+`--move` works with every look. On `camera` the move drives the engine; on the others it becomes precise camera direction in the prompt. A named move beats "the camera moves dramatically" every time.
+
+## For agents
+
+Add `--json` to any command and read the last line of stdout:
+
+```json
+{"ok":true,"file":"/work/clip.mp4","bytes":812344,"jobId":"…","videoUrl":"https://…/generated-videos/….mp4","model":"kling-2.5-turbo-pro","duration":5}
+```
+
+Errors are `{"ok":false,"error":"…","code":N}`. Exit codes: `2` not signed in, `3` cannot reach the server, `4` not enough credits, `5` the model declined the prompt, `64` bad usage, `1` anything else. Progress goes to stderr, results to stdout.
+
+The MIT-licensed agent skills that teach Claude Code, Cursor and Codex how to use this CLI well live in the [`skills`](../skills) directory.
+
+## Configuration
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `PARLEY_BACKEND_URL` | `https://licensing.parley.live` | API host |
+| `PARLEY_AUTH_WEB_URL` | `https://labs.parley.live` | where `login` sends the browser |
+| `PARLEY_HOME` | `~/.parley` | credentials directory |
+| `PARLEY_TOKEN` | | use this session token instead of the stored one (CI) |
+| `PARLEY_NO_BROWSER` | | `1` prints the sign-in link instead of opening it |
+
+## Development
+
+```bash
+npm install
+npm test          # builds, then drives the binary against a local mock API (no network, no credits)
+```
+
+Node 20 or newer. No runtime dependencies.
+
+## License
+
+MIT

package/dist/client.js

@@ -0,0 +1,174 @@
+/**
+ * Parley API client for the CLI: credential store + thin HTTP layer.
+ *
+ * Auth is the same device-code flow the desktop app uses: the CLI asks the
+ * server for a short user code, the user signs in once in their browser, and
+ * the server hands the CLI a session token. The token lives in
+ * $PARLEY_HOME/credentials.json (default ~/.parley) with 0600 permissions and
+ * is sent as `Authorization: Bearer <token>` on every call. Nothing else is
+ * stored, and no secret is ever placed in a URL.
+ *
+ * Environment:
+ *   PARLEY_BACKEND_URL   API host (default https://licensing.parley.live)
+ *   PARLEY_AUTH_WEB_URL  sign-in page (default https://labs.parley.live)
+ *   PARLEY_HOME          credentials directory (default ~/.parley)
+ *   PARLEY_TOKEN         use this session token instead of the stored one
+ *   PARLEY_NO_BROWSER    set to 1 to print the sign-in link instead of opening it
+ */
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+export const DEFAULT_BACKEND_URL = 'https://licensing.parley.live';
+export const DEFAULT_AUTH_WEB_URL = 'https://labs.parley.live';
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+    }
+}
+export function homeDir() {
+    return process.env.PARLEY_HOME || path.join(homedir(), '.parley');
+}
+function credentialsPath() {
+    return path.join(homeDir(), 'credentials.json');
+}
+export function backendUrl(override) {
+    const raw = override || process.env.PARLEY_BACKEND_URL || loadCredentials()?.backendUrl || DEFAULT_BACKEND_URL;
+    return raw.replace(/\/+$/, '');
+}
+export function authWebUrl() {
+    return (process.env.PARLEY_AUTH_WEB_URL || DEFAULT_AUTH_WEB_URL).replace(/\/+$/, '');
+}
+export function loadCredentials() {
+    try {
+        const p = credentialsPath();
+        if (!existsSync(p))
+            return null;
+        const parsed = JSON.parse(readFileSync(p, 'utf8'));
+        if (parsed && typeof parsed.token === 'string' && typeof parsed.backendUrl === 'string')
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    mkdirSync(homeDir(), { recursive: true });
+    const p = credentialsPath();
+    writeFileSync(p, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch { /* windows */ }
+    return p;
+}
+export function clearCredentials() {
+    const p = credentialsPath();
+    if (!existsSync(p))
+        return false;
+    unlinkSync(p);
+    return true;
+}
+export function currentToken() {
+    return process.env.PARLEY_TOKEN || loadCredentials()?.token || null;
+}
+/** Open a URL in the user's browser; returns false when it could not. */
+export function openInBrowser(url) {
+    if (process.env.PARLEY_NO_BROWSER === '1')
+        return false;
+    try {
+        const platform = process.platform;
+        const child = platform === 'win32'
+            ? spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true })
+            : platform === 'darwin'
+                ? spawn('open', [url], { stdio: 'ignore', detached: true })
+                : spawn('xdg-open', [url], { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Call the API and parse JSON. Maps the server's conventions to typed errors:
+ * 401 → sign in again; 402 → credits; HTTP 200 + {ok:false,error} → error.
+ */
+export async function api(pathname, opts = {}) {
+    const base = backendUrl(opts.backend);
+    const url = `${base}${pathname.startsWith('/') ? pathname : `/${pathname}`}`;
+    const headers = { Accept: 'application/json', 'User-Agent': 'parley-live/0.1.0' };
+    if (opts.auth !== false) {
+        const token = currentToken();
+        if (!token)
+            throw new CliError('Not signed in. Run `parley login` first.', 2);
+        headers.Authorization = `Bearer ${token}`;
+    }
+    let body;
+    if (opts.form) {
+        body = opts.form;
+    }
+    else if (opts.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        body = JSON.stringify(opts.body);
+    }
+    let res;
+    try {
+        res = await fetch(url, { method: opts.method || (body ? 'POST' : 'GET'), headers, body });
+    }
+    catch (e) {
+        throw new CliError(`Could not reach ${base}: ${e?.message || e}`, 3);
+    }
+    const text = await res.text();
+    let json = null;
+    try {
+        json = text ? JSON.parse(text) : null;
+    }
+    catch {
+        json = { raw: text };
+    }
+    if (res.status === 401)
+        throw new CliError('Your session has expired or is invalid. Run `parley login` again.', 2);
+    if (res.status === 402) {
+        throw new CliError(json?.message || json?.error || 'Not enough credits for this request. Top up at https://labs.parley.live and try again.', 4);
+    }
+    if (!res.ok)
+        throw new CliError(json?.error || json?.message || `${res.status} ${res.statusText} from ${pathname}`, 1);
+    if (json && json.ok === false)
+        throw new CliError(json.error || 'The server declined the request.', 1);
+    if (json && json.refused === true)
+        throw new CliError(json.error || 'The model declined this prompt.', 5);
+    return json;
+}
+/** Download a URL (with Bearer auth when it is on our backend) to a file. */
+export async function downloadTo(url, outPath) {
+    const headers = {};
+    const token = currentToken();
+    if (token && url.startsWith(backendUrl()))
+        headers.Authorization = `Bearer ${token}`;
+    const res = await fetch(url, { headers });
+    if (!res.ok)
+        throw new CliError(`Download failed (HTTP ${res.status}) from ${url}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    mkdirSync(path.dirname(path.resolve(outPath)), { recursive: true });
+    writeFileSync(outPath, buf);
+    return buf.length;
+}
+/** Local file → data: URI (what the API accepts for reference images). */
+export function fileToDataUri(filePath) {
+    const buf = readFileSync(filePath);
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    const mime = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : ext === 'webp' ? 'image/webp' : ext === 'gif' ? 'image/gif' : 'image/png';
+    return `data:${mime};base64,${buf.toString('base64')}`;
+}
+export function isUrl(s) {
+    return /^https?:\/\//i.test(s);
+}
+export function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/index.js

@@ -0,0 +1,507 @@
+#!/usr/bin/env node
+/**
+ * parley — generate images, video clips, YouTube thumbnails and product ads
+ * from the terminal. Every command supports --json for agents.
+ *
+ *   parley login                         sign in (browser, one time)
+ *   parley account                       credit balance
+ *   parley engines                       which video engines are live + rates
+ *   parley camera-moves                  the named camera-move presets
+ *   parley image "<prompt>" [...]        generate an image
+ *   parley video "<prompt>" [...]        generate a clip / animate a still
+ *   parley thumbnail "<title>" [...]     YouTube thumbnail variants
+ *   parley ugc-ad --product <img> ...    spokesperson product ad
+ *
+ * Run `parley help <command>` for the flags of one command.
+ */
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { api, authWebUrl, backendUrl, clearCredentials, CliError, downloadTo, fileToDataUri, isUrl, loadCredentials, openInBrowser, saveCredentials, sleep, } from './client.js';
+const VERSION = '0.1.0';
+function parseArgs(argv) {
+    const out = { command: '', positionals: [], flags: {} };
+    const rest = [...argv];
+    out.command = rest.shift() || 'help';
+    while (rest.length) {
+        const a = rest.shift();
+        if (a === '--') {
+            out.positionals.push(...rest);
+            break;
+        }
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            const key = (eq > 0 ? a.slice(2, eq) : a.slice(2)).trim();
+            let value = eq > 0 ? a.slice(eq + 1) : true;
+            if (value === true && rest.length && !rest[0].startsWith('--'))
+                value = rest.shift();
+            const prev = out.flags[key];
+            if (prev === undefined)
+                out.flags[key] = value;
+            else if (Array.isArray(prev))
+                prev.push(String(value));
+            else
+                out.flags[key] = [String(prev), String(value)];
+        }
+        else {
+            out.positionals.push(a);
+        }
+    }
+    return out;
+}
+const str = (v, fallback) => v === undefined ? fallback : Array.isArray(v) ? v[v.length - 1] : v === true ? fallback : String(v);
+const list = (v) => v === undefined || v === true ? [] : Array.isArray(v) ? v : String(v).split(',').map((s) => s.trim()).filter(Boolean);
+const num = (v, fallback) => {
+    const s = str(v);
+    const n = s === undefined ? NaN : Number(s);
+    return Number.isFinite(n) ? n : fallback;
+};
+// ── output ───────────────────────────────────────────────────────────
+let JSON_MODE = false;
+function emit(obj, human) {
+    if (JSON_MODE)
+        console.log(JSON.stringify(obj));
+    else
+        console.log(human);
+}
+function note(msg) {
+    if (!JSON_MODE)
+        console.error(msg);
+}
+// ── commands ─────────────────────────────────────────────────────────
+async function cmdLogin(p) {
+    const backend = backendUrl(str(p.flags.backend));
+    const started = await api('/api/auth/device/start', { method: 'POST', body: {}, auth: false, backend });
+    const link = `${authWebUrl()}/desktop-auth?code=${encodeURIComponent(started.user_code)}`;
+    const opened = openInBrowser(link);
+    // Always on stderr, even in --json mode: an agent driving `parley login
+    // --json` must be able to relay the link to the person who has to click it.
+    console.error(opened
+        ? `Opening your browser to sign in. If it did not open, visit:\n  ${link}\nCode: ${started.user_code}`
+        : `Sign in here (one time):\n  ${link}\nCode: ${started.user_code}`);
+    const intervalMs = Math.max(1000, (started.interval || 3) * 1000);
+    const deadline = Date.now() + Math.min(started.expires_in || 600, 600) * 1000;
+    while (Date.now() < deadline) {
+        await sleep(intervalMs);
+        let poll;
+        try {
+            poll = await api('/api/auth/device/poll', { method: 'POST', body: { device_code: started.device_code }, auth: false, backend });
+        }
+        catch (e) {
+            if (e instanceof CliError && /expired/i.test(e.message))
+                throw new CliError('The sign-in code expired. Run `parley login` again.');
+            throw e;
+        }
+        if (poll.status === 'ok' && poll.auth_token && poll.user_id) {
+            const file = saveCredentials({ backendUrl: backend, token: poll.auth_token, userId: poll.user_id, email: poll.email || null, savedAt: new Date().toISOString() });
+            emit({ ok: true, email: poll.email || null, userId: poll.user_id, credentials: file }, `Signed in as ${poll.email || poll.user_id}. Credentials saved to ${file}`);
+            return;
+        }
+    }
+    throw new CliError('Timed out waiting for the browser sign-in. Run `parley login` again.');
+}
+async function cmdLogout() {
+    const removed = clearCredentials();
+    emit({ ok: true, removed }, removed ? 'Signed out.' : 'You were not signed in.');
+}
+async function cmdWhoami() {
+    const c = loadCredentials();
+    if (!c && !process.env.PARLEY_TOKEN)
+        throw new CliError('Not signed in. Run `parley login`.', 2);
+    emit({ ok: true, email: c?.email ?? null, userId: c?.userId ?? null, backendUrl: backendUrl() }, `${c?.email || c?.userId || '(token from PARLEY_TOKEN)'} @ ${backendUrl()}`);
+}
+async function cmdAccount() {
+    const bal = await api('/api/credits/balance');
+    emit({ ok: true, ...bal }, `Credits: ${bal.credits_balance}`);
+}
+async function cmdEngines() {
+    const e = await api('/video/engines', { auth: false });
+    if (JSON_MODE) {
+        console.log(JSON.stringify({ ok: true, ...e }));
+        return;
+    }
+    for (const [id, info] of Object.entries(e.engines)) {
+        const rate = info.creditsPerSec == null ? (info.note || '') : `${info.creditsPerSec} cr/s`;
+        console.log(`${info.ready ? 'live ' : 'off  '} ${id.padEnd(16)} ${String(rate).padEnd(10)} ${info.label}${info.fallback ? `  (falls back to ${info.fallback})` : ''}`);
+    }
+}
+async function cmdCameraMoves() {
+    const e = await api('/video/engines', { auth: false });
+    if (JSON_MODE) {
+        console.log(JSON.stringify({ ok: true, cameraMoves: e.cameraMoves }));
+        return;
+    }
+    for (const m of e.cameraMoves)
+        console.log(`${m.slug.padEnd(20)} ${m.label}`);
+}
+function outPathFor(p, defaultName) {
+    const o = str(p.flags.out);
+    return o ? o : path.join(process.cwd(), defaultName);
+}
+async function cmdImage(p) {
+    const prompt = p.positionals.join(' ').trim();
+    if (!prompt)
+        throw new CliError('Usage: parley image "<prompt>" [--model gpt-image-2|gemini-3-pro-image-preview] [--size 1024x1024|1024x1536|1536x1024] [--quality low|medium|high] [--image-size 1K|2K|4K] [--ref <file|url>]... [--out file.png]');
+    const refs = list(p.flags.ref).map((r) => (isUrl(r) ? r : fileToDataUri(r)));
+    const body = { prompt };
+    const model = str(p.flags.model);
+    if (model)
+        body.model = model;
+    const size = str(p.flags.size);
+    if (size)
+        body.gptImageSize = size;
+    const quality = str(p.flags.quality);
+    if (quality)
+        body.gptImageQuality = quality;
+    const imageSize = str(p.flags['image-size']);
+    if (imageSize)
+        body.imageSize = imageSize;
+    if (refs.length)
+        body.inputImages = refs;
+    note('Generating image…');
+    const r = await api('/image/generate', { body });
+    const ext = /jpe?g/.test(r.mimeType || '') ? 'jpg' : /webp/.test(r.mimeType || '') ? 'webp' : 'png';
+    const out = outPathFor(p, `parley-image-${Date.now()}.${ext}`);
+    let bytes = 0;
+    if (r.imageUrl)
+        bytes = await downloadTo(r.imageUrl, out);
+    else if (r.dataUrl) {
+        const m = /^data:[^;]+;base64,(.*)$/.exec(r.dataUrl);
+        if (!m)
+            throw new CliError('The server returned an image in an unexpected format.');
+        const buf = Buffer.from(m[1], 'base64');
+        mkdirSync(path.dirname(path.resolve(out)), { recursive: true });
+        (await import('node:fs')).writeFileSync(out, buf);
+        bytes = buf.length;
+    }
+    else
+        throw new CliError('The server returned no image.');
+    emit({ ok: true, file: out, bytes, model: r.model, imageUrl: r.imageUrl ?? null, revisedPrompt: r.revisedPrompt ?? null }, `Saved ${out} (${Math.round(bytes / 1024)} KB, ${r.model})${r.imageUrl ? `\nHosted: ${r.imageUrl}` : ''}`);
+}
+const LOOKS = ['fast', 'standard', 'cinematic', 'photoreal', 'transform', 'camera'];
+const LOOK_TO_PROVIDER = {
+    fast: 'hailuo', standard: 'kling', illustrated: 'kling', cinematic: 'veo', photoreal: 'seedance-2.0', transform: 'gemini-omni', camera: 'higgsfield-dop',
+};
+async function cmdVideo(p) {
+    const prompt = p.positionals.join(' ').trim();
+    if (!prompt)
+        throw new CliError(`Usage: parley video "<motion prompt>" [--image <file|url>] [--look ${LOOKS.join('|')}] [--move <slug>]... [--duration 5] [--ratio 16:9|9:16|1:1] [--out clip.mp4]`);
+    const look = str(p.flags.look, 'standard');
+    if (!(look in LOOK_TO_PROVIDER))
+        throw new CliError(`Unknown --look "${look}". Use one of: ${LOOKS.join(', ')}.`);
+    const image = str(p.flags.image);
+    const imageFiles = image ? [isUrl(image) ? image : fileToDataUri(image)] : [];
+    if (!image && look !== 'photoreal') {
+        throw new CliError('Every look except "photoreal" animates a still: pass --image <file|url> (make one with `parley image` first), or use --look photoreal for text-to-video.');
+    }
+    const moves = list(p.flags.move).slice(0, 3);
+    const ratio = str(p.flags.ratio, '16:9');
+    const duration = num(p.flags.duration, 5);
+    const body = {
+        provider: LOOK_TO_PROVIDER[look], prompt, duration, ratio, resolution: '720p',
+        functionMode: 'omni_reference', modelSpeed: 'seedance_2.0_fast', generate_audio: true,
+        ...(imageFiles.length ? { image_files: imageFiles } : {}),
+        ...(moves.length ? { motions: moves } : {}),
+    };
+    note(`Submitting to the ${look} tier${moves.length ? ` with camera moves ${moves.join(', ')}` : ''}…`);
+    const created = await api('/video/generate', { body });
+    const jobId = created.jobId;
+    if (!jobId)
+        throw new CliError('The server did not start a job.');
+    let lastStage = '';
+    const deadline = Date.now() + 30 * 60 * 1000;
+    while (Date.now() < deadline) {
+        await sleep(3000);
+        const s = await api(`/video/jobs/${jobId}`);
+        const stage = s.progress?.stage || s.status;
+        if (stage !== lastStage) {
+            note(`  ${stage}${s.progress?.message ? ` – ${s.progress.message}` : ''}`);
+            lastStage = stage;
+        }
+        if (s.status === 'succeeded')
+            break;
+        if (s.status === 'failed')
+            throw new CliError(s.error || 'Video generation failed.');
+    }
+    const r = await api(`/video/jobs/${jobId}/result`);
+    const out = outPathFor(p, `parley-video-${jobId}.mp4`);
+    const src = r.videoUrl || `${backendUrl()}/video/jobs/${jobId}/result?download=1`;
+    const bytes = await downloadTo(src, out);
+    emit({ ok: true, file: out, bytes, jobId, videoUrl: r.videoUrl ?? null, model: r.model ?? null, duration: r.duration ?? null, width: r.width ?? null, height: r.height ?? null, deduped: created.deduped === true }, `Saved ${out} (${Math.round(bytes / 1024)} KB, ${r.model || look}, ${r.duration ?? '?'}s)${r.videoUrl ? `\nHosted: ${r.videoUrl}` : ''}`);
+}
+async function cmdThumbnail(p) {
+    const title = p.positionals.join(' ').trim();
+    if (!title)
+        throw new CliError('Usage: parley thumbnail "<video title>" [--variants 1-3] [--overlay "2-4 WORDS"] [--accent WORD] [--person true|false] [--model X] [--out dir]');
+    const body = { title, variants: Math.min(3, Math.max(1, num(p.flags.variants, 3))) };
+    const overlay = str(p.flags.overlay);
+    if (overlay)
+        body.overlayText = overlay;
+    const accent = str(p.flags.accent);
+    if (accent)
+        body.accentWord = accent;
+    const model = str(p.flags.model);
+    if (model)
+        body.model = model;
+    const person = str(p.flags.person);
+    if (person)
+        body.includePerson = person === 'true';
+    note('Generating thumbnail variants…');
+    const r = await api('/image/thumbnail', { body });
+    const urls = Array.isArray(r.variants) ? r.variants.map((v) => v.imageUrl || v.url).filter(Boolean)
+        : Array.isArray(r.imageUrls) ? r.imageUrls : r.imageUrl ? [r.imageUrl] : [];
+    const dir = str(p.flags.out) || path.join(process.cwd(), `parley-thumbnails-${Date.now()}`);
+    mkdirSync(dir, { recursive: true });
+    const files = [];
+    for (let i = 0; i < urls.length; i++) {
+        const f = path.join(dir, `thumbnail-${i + 1}.png`);
+        await downloadTo(urls[i], f);
+        files.push(f);
+    }
+    emit({ ok: true, files, urls, creditsCharged: r.creditsCharged ?? null, raw: files.length ? undefined : r }, files.length ? `Saved ${files.length} variant${files.length === 1 ? '' : 's'} to ${dir} (${r.creditsCharged ?? '?'} credits)` : `Server response:\n${JSON.stringify(r, null, 2)}`);
+}
+const ANGLES = ['problem_solution', 'honest_review', 'unboxing', 'before_after', 'founder'];
+const MARKETPLACES = ['amazon', 'ebay', 'etsy', 'tiktok_shop', 'shopify', 'other'];
+async function cmdUgcAd(p) {
+    const product = str(p.flags.product);
+    const name = str(p.flags.name);
+    if (!product || !name) {
+        throw new CliError(`Usage: parley ugc-ad --product <image file> --name "Product name" [--actor maya|jordan|sofia|marcus | --face <image file>] [--angle ${ANGLES.join('|')}] [--marketplace ${MARKETPLACES.join('|')}] [--points "point one;point two"] [--seconds 8] [--url https://...] [--out ad.mp4]`);
+    }
+    if (!existsSync(product))
+        throw new CliError(`Product image not found: ${product}`);
+    const angle = str(p.flags.angle, 'problem_solution');
+    if (!ANGLES.includes(angle))
+        throw new CliError(`--angle must be one of ${ANGLES.join(', ')}`);
+    const marketplace = str(p.flags.marketplace, 'amazon');
+    if (!MARKETPLACES.includes(marketplace))
+        throw new CliError(`--marketplace must be one of ${MARKETPLACES.join(', ')}`);
+    const form = new FormData();
+    const fileBlob = (f) => new Blob([readFileSync(f)], { type: /\.jpe?g$/i.test(f) ? 'image/jpeg' : 'image/png' });
+    form.append('productImage', fileBlob(product), path.basename(product));
+    form.append('productName', name);
+    form.append('angle', angle);
+    form.append('marketplace', marketplace);
+    form.append('sellingPoints', JSON.stringify(list(p.flags.points).flatMap((s) => s.split(';')).map((s) => s.trim()).filter(Boolean)));
+    form.append('spokespersonSeconds', String(num(p.flags.seconds, 8)));
+    const face = str(p.flags.face);
+    const actor = str(p.flags.actor);
+    if (face) {
+        if (!existsSync(face))
+            throw new CliError(`Face image not found: ${face}`);
+        form.append('actorImage', fileBlob(face), path.basename(face));
+    }
+    else
+        form.append('actorId', actor || 'maya');
+    const url = str(p.flags.url);
+    if (url)
+        form.append('destinationUrl', url);
+    note('Submitting the ad…');
+    const created = await api('/api/ugc-ad/generate', { form });
+    const jobId = created.jobId || created.id;
+    if (!jobId)
+        throw new CliError('The server did not start an ad job.');
+    let last = '';
+    const deadline = Date.now() + 40 * 60 * 1000;
+    let job = null;
+    while (Date.now() < deadline) {
+        await sleep(4000);
+        job = await api(`/api/ugc-ad/jobs/${jobId}`);
+        const stage = job.progress?.stage || job.progress?.message || job.status;
+        if (stage !== last) {
+            note(`  ${stage}`);
+            last = stage;
+        }
+        if (job.status === 'succeeded' || job.status === 'completed' || job.status === 'done')
+            break;
+        if (job.status === 'failed')
+            throw new CliError(job.error || 'Ad generation failed.');
+    }
+    const videoUrl = job?.result?.videoUrl || job?.result?.finalVideoUrl || job?.result?.url;
+    const out = outPathFor(p, `parley-ad-${jobId}.mp4`);
+    const bytes = videoUrl ? await downloadTo(videoUrl, out) : 0;
+    emit({ ok: true, jobId, file: videoUrl ? out : null, bytes, videoUrl: videoUrl ?? null, result: job?.result ?? null }, videoUrl ? `Saved ${out} (${Math.round(bytes / 1024)} KB)\nHosted: ${videoUrl}` : `Finished. Result:\n${JSON.stringify(job?.result, null, 2)}`);
+}
+const YT_TIERS = ['fast', 'standard', 'cinematic'];
+/**
+ * parley youtube --beat <https still> ... [--narration <https audio>] [--music <https audio>]
+ *   [--tier fast|standard|cinematic] [--captions] [--silent] [--project <workspace id>] [--out video.mp4]
+ * Hands an ordered list of beat stills (made with `parley image`, same ratio and
+ * look) to Parley's production orchestrator, which animates each beat, cuts
+ * them to the narration with crossfades, ducks the music, optionally burns
+ * captions, and returns one finished MP4.
+ */
+async function cmdYoutube(p) {
+    const beats = list(p.flags.beat);
+    if (beats.length === 0) {
+        throw new CliError(`Usage: parley youtube --beat <https still> [--beat ...] [--narration <https audio>] [--music <https audio>] [--tier ${YT_TIERS.join('|')}] [--captions] [--silent] [--project <workspace id>] [--out video.mp4]\n  Beats are the hosted image URLs "parley image" prints, in narration order.`);
+    }
+    const bad = beats.find((b) => !isUrl(b));
+    if (bad)
+        throw new CliError(`Every --beat must be a public https URL (got "${bad}"). Make the still with \`parley image\` and pass its hosted URL.`);
+    const tier = str(p.flags.tier, 'standard');
+    if (!YT_TIERS.includes(tier))
+        throw new CliError(`--tier must be one of ${YT_TIERS.join(', ')}`);
+    const narration = str(p.flags.narration);
+    const music = str(p.flags.music);
+    const project = str(p.flags.project);
+    const silent = p.flags.silent === true;
+    if (!narration && !silent) {
+        throw new CliError('Pass --narration <https audio URL> (the voiceover the video is cut to), or --silent if the user explicitly wants no voiceover.');
+    }
+    const body = {
+        beats: beats.map((imageUrl) => ({ imageUrl })),
+        tier,
+        captions: p.flags.captions === true,
+        ...(narration ? { narrationUrl: narration } : {}),
+        ...(music ? { musicUrl: music } : {}),
+        ...(silent ? { silent: true } : {}),
+        ...(project ? { projectId: project } : {}),
+    };
+    note(`Submitting ${beats.length} beat${beats.length === 1 ? '' : 's'} on the ${tier} tier…`);
+    const created = await api('/api/youtube/produce', { body });
+    if (!created.jobId)
+        throw new CliError('The server did not start a production.');
+    note(`Production ${created.jobId} started${created.estimatedCredits != null ? ` (about ${created.estimatedCredits} credits)` : ''}. This takes minutes.`);
+    let last = '';
+    const deadline = Date.now() + 60 * 60 * 1000;
+    let job = null;
+    while (Date.now() < deadline) {
+        await sleep(5000);
+        job = await api(`/api/youtube/produce/${created.jobId}`);
+        const stage = job.progress ? `${job.progress.stage}${job.progress.total ? ` ${job.progress.done}/${job.progress.total}` : ''}${job.progress.message ? ` – ${job.progress.message}` : ''}` : job.status;
+        if (stage !== last) {
+            note(`  ${stage}`);
+            last = stage;
+        }
+        if (job.status === 'succeeded')
+            break;
+        if (job.status === 'failed')
+            throw new CliError(job.error || 'Production failed.');
+    }
+    const videoUrl = job?.result?.videoUrl;
+    if (!videoUrl)
+        throw new CliError('Production finished without a video URL.');
+    const out = outPathFor(p, `parley-youtube-${created.jobId}.mp4`);
+    const bytes = await downloadTo(videoUrl, out);
+    emit({ ok: true, file: out, bytes, jobId: created.jobId, videoUrl, estimatedCredits: created.estimatedCredits ?? null, result: job.result }, `Saved ${out} (${Math.round(bytes / 1024)} KB)\nHosted: ${videoUrl}`);
+}
+/**
+ * parley api <GET|POST|PATCH|PUT|DELETE> <path> [--data '<json>' | --data @file.json]
+ * Signed raw call to any Parley endpoint (the Studio's projects, characters,
+ * shots, renders and reels live here). Prints the JSON reply.
+ */
+async function cmdApi(p) {
+    const [methodRaw, pathname] = p.positionals;
+    const method = (methodRaw || '').toUpperCase();
+    if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(method) || !pathname || !pathname.startsWith('/')) {
+        throw new CliError('Usage: parley api <GET|POST|PATCH|PUT|DELETE> </path> [--data \'{"json":true}\' | --data @body.json]');
+    }
+    let body;
+    const data = str(p.flags.data);
+    if (data !== undefined) {
+        const text = data.startsWith('@') ? readFileSync(data.slice(1), 'utf8') : data;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            throw new CliError('--data must be valid JSON (or @file.json).');
+        }
+    }
+    const r = await api(pathname, { method, ...(body !== undefined ? { body } : {}) });
+    if (JSON_MODE)
+        console.log(JSON.stringify(r));
+    else
+        console.log(JSON.stringify(r, null, 2));
+}
+function help(topic) {
+    const lines = {
+        login: 'parley login [--backend URL]\n  Sign in once in your browser. Stores a session token under ~/.parley (or $PARLEY_HOME).',
+        image: 'parley image "<prompt>" [--model gpt-image-2|gemini-3-pro-image-preview] [--size 1024x1024|1024x1536|1536x1024] [--quality low|medium|high] [--image-size 1K|2K|4K] [--ref <file|url>]... [--out file]\n  Generate an image. --ref passes reference images (identity / style locks).',
+        video: `parley video "<motion prompt>" --image <file|url> [--look ${LOOKS.join('|')}] [--move <slug>]... [--duration 5] [--ratio 16:9|9:16|1:1] [--out clip.mp4]\n  Animate a still (or --look photoreal for text-to-video). --move adds named camera moves; see \`parley camera-moves\`.`,
+        thumbnail: 'parley thumbnail "<video title>" [--variants 1-3] [--overlay "2-4 WORDS"] [--accent WORD] [--person true|false] [--out dir]',
+        'ugc-ad': `parley ugc-ad --product <image> --name "Product" [--actor maya|jordan|sofia|marcus | --face <image>] [--angle ${ANGLES.join('|')}] [--marketplace ${MARKETPLACES.join('|')}] [--points "a;b;c"] [--seconds 3-16] [--url https://...] [--out ad.mp4]`,
+        youtube: `parley youtube --beat <https still>... [--narration <https audio>] [--music <https audio>] [--tier ${YT_TIERS.join('|')}] [--captions] [--silent] [--project <workspace id>] [--out video.mp4]\n  Animate ordered beat stills and cut them to the narration into one finished video.`,
+        api: 'parley api <GET|POST|PATCH|PUT|DELETE> </path> [--data \'{...}\' | --data @file.json]\n  Signed raw call to any Parley endpoint (Studio projects, characters, shots, renders, reels).',
+        engines: 'parley engines\n  Which video engines this server can run right now and their credit rates.',
+        'camera-moves': 'parley camera-moves\n  The named camera-move presets accepted by `parley video --move`.',
+        account: 'parley account\n  Your credit balance.',
+    };
+    if (topic && lines[topic]) {
+        console.log(lines[topic]);
+        return;
+    }
+    console.log(`parley ${VERSION}\n\n${Object.values(lines).map((l) => '  ' + l.split('\n')[0]).join('\n')}\n\n  parley whoami | logout | help <command>\n\nGlobal flags: --json (machine-readable output), --backend <url>.`);
+}
+async function main(argv) {
+    const p = parseArgs(argv);
+    JSON_MODE = p.flags.json === true || p.flags.json === 'true';
+    if (p.flags.version === true || p.command === 'version' || p.command === '--version') {
+        console.log(VERSION);
+        return 0;
+    }
+    try {
+        switch (p.command) {
+            case 'login':
+                await cmdLogin(p);
+                break;
+            case 'logout':
+                await cmdLogout();
+                break;
+            case 'whoami':
+                await cmdWhoami();
+                break;
+            case 'account':
+            case 'balance':
+                await cmdAccount();
+                break;
+            case 'engines':
+                await cmdEngines();
+                break;
+            case 'camera-moves':
+            case 'moves':
+                await cmdCameraMoves();
+                break;
+            case 'image':
+                await cmdImage(p);
+                break;
+            case 'video':
+                await cmdVideo(p);
+                break;
+            case 'thumbnail':
+                await cmdThumbnail(p);
+                break;
+            case 'ugc-ad':
+            case 'ad':
+                await cmdUgcAd(p);
+                break;
+            case 'youtube':
+            case 'yt':
+                await cmdYoutube(p);
+                break;
+            case 'api':
+                await cmdApi(p);
+                break;
+            case 'help':
+            case '--help':
+            case '-h':
+                help(p.positionals[0]);
+                break;
+            default:
+                throw new CliError(`Unknown command "${p.command}". Run \`parley help\`.`, 64);
+        }
+        return 0;
+    }
+    catch (e) {
+        const code = e instanceof CliError ? e.exitCode : 1;
+        if (JSON_MODE)
+            console.log(JSON.stringify({ ok: false, error: e?.message || String(e), code }));
+        else
+            console.error(`error: ${e?.message || e}`);
+        return code;
+    }
+}
+// Set the exit code and let the event loop drain rather than calling
+// process.exit(): a hard exit while a download socket is still closing
+// aborts Node on Windows (libuv UV_HANDLE_CLOSING assertion) even after the
+// result was printed, which turned every successful download into a crash.
+main(process.argv.slice(2)).then((code) => { process.exitCode = code; });

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "parley-live",
+  "version": "0.1.0",
+  "description": "Generate images, video clips, YouTube thumbnails and product ads from the terminal with Parley. Built for coding agents: every command has a --json mode.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "parley": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node test/cli.test.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "parley",
+    "ai",
+    "video",
+    "image",
+    "cli",
+    "agent-skills"
+  ]
+}