parley-live 0.3.0 → 0.4.1

package/README.md

@@ -18,7 +18,8 @@ parley ugc-ad --product product.jpg --name "Cold Brew Kit" --actor jordan --mark
 |---|---|
 | `parley doctor [--require <version>]` | Node, server, session, credits, live engines, the `@last` outputs, whether a newer release exists, and the fix for anything missing. `--require` fails "ready" when this CLI is older than what your skills expect. Run it first; `--json` for agents. |
 | `parley voice "<text>" \| --file script.txt` | Narration as a hosted WAV. `--voice warm\|energetic\|documentary\|deep\|bright\|storyteller`, `--quality natural\|fish\|studio`, `--no-fallback`, `--out`. Natural voice: 1 credit per 1,000 characters; studio: 1 per 300. Becomes `@last` for `--narration`. `parley voices` lists personas and prices. |
-| `parley studio …` | The film pipeline without JSON: `character add\|cast\|list`, `shot add\|list`, `render <shotId> [--wait]`, `assemble`, `reels`. Every subcommand takes `--project proj_…`. |
+| `parley studio …` | The film pipeline without JSON: `character add\|cast\|list`, `location add\|cast\|list`, `shot add\|list`, `render <shotId> [--wait]`, `assemble`, `reels`. Every subcommand takes `--project proj_…`. |
+| `parley deploy <dir> --name <slug>` | Ship a built static site (index.html at the root) to a live URL. Reuse `--project proj_…` to redeploy the same site at the same URL. Free. |
 | `parley login [--no-browser]` | Device-code sign-in. Prints a link, you sign in once in the browser, the CLI receives a session token. `--no-browser` prints the link instead of opening it (cloud sandboxes, SSH). |
 | `parley account` | Credit balance. |
 | `parley engines` | Which video engines this server can run right now, with credit rates. |
@@ -27,7 +28,7 @@ parley ugc-ad --product product.jpg --name "Cold Brew Kit" --actor jordan --mark
 | `parley video "<motion prompt>"` | Animate a still (`--image <file\|url\|@last>`) 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 youtube` | A complete faceless video from ordered beat stills: animated per beat (one 5 s clip each, so bring about one beat per 5 s of narration; a narration the beats cannot carry is refused before anything is charged), 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. |
 

package/dist/client.js

@@ -188,7 +188,7 @@ export function rememberLast(kind, entry) {
     try {
         mkdirSync(homeDir(), { recursive: true });
         const cur = loadLast();
-        cur[kind] = { file: path.resolve(entry.file), url: entry.url, at: new Date().toISOString() };
+        cur[kind] = { file: entry.file ? path.resolve(entry.file) : null, url: entry.url, at: new Date().toISOString() };
         writeFileSync(lastPath(), JSON.stringify(cur, null, 2) + '\n');
     }
     catch { /* best effort: chaining is a convenience, never a failure */ }
@@ -198,9 +198,10 @@ export function resolveRef(ref, kind) {
     if (ref !== '@last' && ref !== `@last-${kind}`)
         return ref;
     const last = loadLast()[kind];
-    if (!last)
+    const ref2 = last?.url || last?.file;
+    if (!ref2)
         throw new CliError(`No previous ${kind} on this machine yet. Make one first (parley ${kind} …), then pass @last.`);
-    return last.url || last.file;
+    return ref2;
 }
 export function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));

package/dist/index.js

@@ -14,10 +14,22 @@
  *
  * Run `parley help <command>` for the flags of one command.
  */
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { api, authWebUrl, backendUrl, clearCredentials, CliError, downloadTo, fileToDataUri, isUrl, loadCredentials, loadLast, openInBrowser, rememberLast, resolveRef, saveCredentials, sleep, } from './client.js';
-const VERSION = '0.3.0';
+const VERSION = '0.4.1';
+/** Server advice written for Parley's in-app agent names its tools; a CLI user
+ *  has commands instead, so the same advice is re-spoken in CLI terms. */
+function humanizeServerMessage(message) {
+    return message
+        .replace(/\bvia generate_video\b/g, 'with parley video')
+        .replace(/\bcall assemble_video again\b/g, 'run parley youtube again')
+        .replace(/\bgenerate_video\b/g, 'parley video')
+        .replace(/\bassemble_video\b/g, 'parley youtube')
+        .replace(/\bproduce_full_video\b/g, 'parley youtube')
+        .replace(/\bgenerate_voiceover\b/g, 'parley voice')
+        .replace(/\bgenerate_image\b/g, 'parley image');
+}
 /** Semver-ish compare: 1 if a > b, -1 if a < b, 0 if equal (numeric parts only). */
 function compareVersions(a, b) {
     const pa = a.replace(/^v/, '').split('.').map((x) => parseInt(x, 10) || 0);
@@ -347,7 +359,9 @@ async function cmdUgcAd(p) {
         if (job.status === 'failed')
             throw new CliError(job.error || 'Ad generation failed.');
     }
-    const videoUrl = job?.result?.videoUrl || job?.result?.finalVideoUrl || job?.result?.url;
+    // The ad orchestrator reports the finished file as outputUrl; the other
+    // shapes cover older jobs and the generic video result.
+    const videoUrl = job?.result?.outputUrl || 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)}`);
@@ -364,7 +378,8 @@ const YT_TIERS = ['fast', 'standard', 'cinematic'];
 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.`);
+        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.
+  Every beat becomes one 5 s clip and the cut refuses more than 15% slow motion: bring about one beat per 5 s of narration.`);
     }
     const bad = beats.find((b) => !isUrl(b));
     if (bad)
@@ -430,6 +445,53 @@ const VOICE_TIERS = ['natural', 'fish', 'studio'];
  * synthetic fallback voice silently (voiceWarning), and --no-fallback refuses
  * it outright. The result is @last for --narration.
  */
+const VOICE_MAX_CHARS = 5000;
+const VOICE_SPLIT_TARGET = 4500;
+/**
+ * Split a long narration into sections of at most `max` characters, cutting
+ * at paragraph breaks first, then sentence ends, then (last resort) spaces,
+ * so a section never ends mid-word and rarely mid-sentence.
+ */
+export function splitNarration(text, max = VOICE_SPLIT_TARGET) {
+    const clean = text.replace(/\r\n/g, '\n').trim();
+    if (clean.length <= max)
+        return [clean];
+    const sections = [];
+    let current = '';
+    const push = () => { if (current.trim())
+        sections.push(current.trim()); current = ''; };
+    const units = clean.split(/\n\s*\n/).flatMap((para) => {
+        if (para.length <= max)
+            return [para];
+        const sentences = para.match(/[^.!?]+[.!?]+["')\]]*\s*|[^.!?]+$/g) || [para];
+        return sentences.flatMap((s) => {
+            if (s.length <= max)
+                return [s];
+            const words = s.split(/\s+/);
+            const chunks = [];
+            let w = '';
+            for (const word of words) {
+                if ((w + ' ' + word).trim().length > max) {
+                    chunks.push(w.trim());
+                    w = word;
+                }
+                else
+                    w = (w + ' ' + word).trim();
+            }
+            if (w)
+                chunks.push(w);
+            return chunks;
+        });
+    });
+    for (const unit of units) {
+        const sep = current && /\n\s*\n/.test(clean.slice(clean.indexOf(unit) - 3, clean.indexOf(unit))) ? '\n\n' : ' ';
+        if ((current + sep + unit).trim().length > max)
+            push();
+        current = current ? `${current}${sep}${unit}` : unit;
+    }
+    push();
+    return sections;
+}
 async function cmdVoice(p) {
     const file = str(p.flags.file);
     let text = p.positionals.join(' ').trim();
@@ -439,24 +501,43 @@ async function cmdVoice(p) {
         text = readFileSync(file, 'utf8').trim();
     }
     if (!text)
-        throw new CliError(`Usage: parley voice "<text>" | --file script.txt [--voice ${VOICES.join('|')}] [--quality ${VOICE_TIERS.join('|')}] [--no-fallback] [--out narration.wav]`);
-    if (text.length > 5000)
-        throw new CliError(`The text is ${text.length} characters; each request takes up to 5,000. Split the script into sections and make one file per section.`);
+        throw new CliError(`Usage: parley voice "<text>" | --file script.txt [--voice ${VOICES.join('|')}] [--quality ${VOICE_TIERS.join('|')}] [--split] [--no-fallback] [--out narration.wav]`);
     const voice = str(p.flags.voice);
     if (voice && !VOICES.includes(voice))
         throw new CliError(`--voice must be one of ${VOICES.join(', ')}`);
     const quality = str(p.flags.quality, 'natural');
     if (!VOICE_TIERS.includes(quality))
         throw new CliError(`--quality must be one of ${VOICE_TIERS.join(', ')}`);
-    const body = { text, quality, ...(voice ? { voice } : {}), ...(p.flags['no-fallback'] === true ? { allowFallback: false } : {}) };
-    note(`Narrating ${text.length} characters with the ${quality} voice${voice ? ` (${voice})` : ''}…`);
-    const r = await api('/api/voice/generate', { body });
+    const split = p.flags.split === true || text.length > VOICE_MAX_CHARS;
+    if (text.length > VOICE_MAX_CHARS && p.flags.split !== true) {
+        note(`The text is ${text.length} characters (over one request's ${VOICE_MAX_CHARS}); splitting into sections and joining them into one narration.`);
+    }
+    const sections = split ? splitNarration(text) : [text];
+    const common = { quality, ...(voice ? { voice } : {}), ...(p.flags['no-fallback'] === true ? { allowFallback: false } : {}) };
+    const parts = [];
+    for (let i = 0; i < sections.length; i++) {
+        note(sections.length > 1
+            ? `Narrating section ${i + 1}/${sections.length} (${sections[i].length} characters) with the ${quality} voice${voice ? ` (${voice})` : ''}…`
+            : `Narrating ${sections[i].length} characters with the ${quality} voice${voice ? ` (${voice})` : ''}…`);
+        parts.push(await api('/api/voice/generate', { body: { text: sections[i], ...common } }));
+    }
+    let finalUrl = parts[0].audioUrl;
+    let durationSeconds = parts[0].durationSeconds;
+    if (parts.length > 1) {
+        note(`Joining ${parts.length} sections into one narration…`);
+        const j = await api('/api/voice/join', { body: { urls: parts.map((x) => x.audioUrl) } });
+        finalUrl = j.audioUrl;
+        durationSeconds = j.durationSeconds;
+    }
     const out = outPathFor(p, `parley-voice-${Date.now()}.wav`);
-    const bytes = await downloadTo(r.audioUrl, out);
-    rememberLast('audio', { file: out, url: r.audioUrl });
-    if (r.voiceWarning)
-        console.error(`warning: ${r.voiceWarning}`);
-    emit({ ok: true, file: out, bytes, audioUrl: r.audioUrl, durationSeconds: r.durationSeconds, engine: r.engine, voice: r.voice, creditsCharged: r.creditsCharged, voiceWarning: r.voiceWarning ?? null }, `Saved ${out} (${r.durationSeconds ?? '?'}s, ${r.engine}, ${r.creditsCharged} credits)\nHosted: ${r.audioUrl}`);
+    const bytes = await downloadTo(finalUrl, out);
+    rememberLast('audio', { file: out, url: finalUrl });
+    const warnings = parts.map((x) => x.voiceWarning).filter((w) => !!w);
+    if (warnings.length)
+        console.error(`warning: ${warnings[0]}${warnings.length > 1 ? ` (${warnings.length} sections)` : ''}`);
+    const creditsCharged = parts.reduce((s, x) => s + (x.creditsCharged || 0), 0);
+    const engines = [...new Set(parts.map((x) => x.engine))].join('+');
+    emit({ ok: true, file: out, bytes, audioUrl: finalUrl, durationSeconds, engine: engines, voice: parts[0].voice, creditsCharged, sections: parts.length, sectionUrls: parts.map((x) => x.audioUrl), voiceWarning: warnings[0] ?? null }, `Saved ${out} (${durationSeconds ?? '?'}s, ${engines}, ${creditsCharged} credits${parts.length > 1 ? `, ${parts.length} sections joined` : ''})\nHosted: ${finalUrl}`);
 }
 async function cmdVoices() {
     const v = await api('/api/voice/voices', { auth: false });
@@ -536,6 +617,32 @@ async function cmdStudio(p) {
         const items = Array.isArray(r) ? r : r.characters || [];
         return out({ ok: true, characters: items }, () => items.map((c) => `${c.id}  ${c.name}  refs=${(c.reference_image_paths || []).length}`).join('\n') || '(no characters yet)');
     }
+    if (group === 'location' && action === 'add') {
+        const P = needProject();
+        const name = str(p.flags.name);
+        const description = str(p.flags.description);
+        if (!name || !description)
+            throw new CliError('studio location add needs --name and --description (the place, time of day, light, the props that identify it).');
+        const l = await api(`/api/studio/projects/${P}/locations`, { body: { name, description } });
+        return out({ ok: true, location: l }, () => `Location ${l.name} created: ${l.id}\nNext: parley studio location cast ${l.id}`);
+    }
+    if (group === 'location' && action === 'cast') {
+        if (!target)
+            throw new CliError('Usage: parley studio location cast <locationId> [--count 1] [--force]');
+        const body = { count: num(p.flags.count, 1) };
+        if (p.flags.force === true)
+            body.force = true;
+        note('Casting the location (renders its reference image)…');
+        const r = await api(`/api/studio/locations/${target}/cast`, { body });
+        const refs = r.location?.reference_image_paths || r.reference_image_paths || [];
+        return out({ ok: true, ...r }, () => `${r.skipped_reason ? r.skipped_reason + '\n' : ''}Reference images: ${refs.length ? refs.join(', ') : '(see JSON)'}`);
+    }
+    if (group === 'location' && action === 'list') {
+        const P = needProject();
+        const r = await api(`/api/studio/projects/${P}/locations`);
+        const items = Array.isArray(r) ? r : r.locations || [];
+        return out({ ok: true, locations: items }, () => items.map((l) => `${l.id}  ${l.name}  refs=${(l.reference_image_paths || []).length}`).join('\n') || '(no locations yet)');
+    }
     if (group === 'shot' && action === 'add') {
         const P = needProject();
         const framing = str(p.flags.framing);
@@ -624,8 +731,9 @@ async function cmdStudio(p) {
             body.narrationUrl = resolveRef(narration, 'audio');
         note('Assembling the reel (score generated and ducked automatically)…');
         const reel = await api(`/api/studio/projects/${P}/assemble`, { body });
+        // The reel stays hosted (nothing is downloaded here), so @last carries the URL only.
         if (reel.public_url)
-            rememberLast('video', { file: reel.video_path || reel.public_url, url: reel.public_url });
+            rememberLast('video', { file: null, url: reel.public_url });
         return out({ ok: true, reel }, () => `Reel ${reel.id || ''}: ${reel.public_url || reel.video_path || '(see JSON)'}`);
     }
     if (group === 'reels') {
@@ -634,7 +742,118 @@ async function cmdStudio(p) {
         const items = r.reels || (Array.isArray(r) ? r : []);
         return out({ ok: true, reels: items }, () => items.map((x) => `${x.id}  ${x.public_url || x.video_path}`).join('\n') || '(no reels yet)');
     }
-    throw new CliError('Usage: parley studio <character add|cast|list | shot add|list | render <shotId> | assemble | reels> … (see `parley help studio`)');
+    throw new CliError('Usage: parley studio <character add|cast|list | location add|cast|list | shot add|list | render <shotId> | assemble | reels> … (see `parley help studio`)');
+}
+const DEPLOY_MAX_FILES = 600;
+const DEPLOY_MAX_TOTAL_BYTES = 40 * 1024 * 1024;
+const DEPLOY_SKIP_DIRS = new Set(['node_modules', '.git', '.svn', '.hg', '.parley', '.cache', '.next', '.nuxt', '.turbo', 'coverage']);
+const TEXT_EXT = new Set(['html', 'htm', 'css', 'js', 'mjs', 'cjs', 'map', 'json', 'txt', 'md', 'svg', 'xml', 'webmanifest', 'txt', 'csv', 'ics', 'rss', 'atom', 'yml', 'yaml', 'toml', 'wasm.txt']);
+const MIME = {
+    html: 'text/html', htm: 'text/html', css: 'text/css', js: 'text/javascript', mjs: 'text/javascript', cjs: 'text/javascript', map: 'application/json',
+    json: 'application/json', txt: 'text/plain', md: 'text/markdown', svg: 'image/svg+xml', xml: 'application/xml', webmanifest: 'application/manifest+json',
+    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp', avif: 'image/avif', ico: 'image/x-icon',
+    mp4: 'video/mp4', webm: 'video/webm', mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg',
+    woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf', pdf: 'application/pdf', wasm: 'application/wasm', glb: 'model/gltf-binary',
+};
+function walkDir(root, rel = '') {
+    const out = [];
+    for (const entry of readdirSync(path.join(root, rel), { withFileTypes: true })) {
+        if (entry.name.startsWith('.DS_Store'))
+            continue;
+        const r = rel ? `${rel}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (!DEPLOY_SKIP_DIRS.has(entry.name))
+                out.push(...walkDir(root, r));
+        }
+        else if (entry.isFile())
+            out.push(r);
+    }
+    return out;
+}
+/**
+ * parley deploy <dir> --name <project> [--project proj_…] [--summary "…"]
+ * Ships a built static site (the folder with index.html at its root) to
+ * Parley's Cloudflare Pages deploy: every file is written into a fresh
+ * workspace (text as text, binaries base64), then deployed. Prints the live
+ * URL. Static only: the server's deploy is a direct upload with no build
+ * step, so run your build first and point this at its output.
+ */
+async function cmdDeploy(p) {
+    const dir = p.positionals[0];
+    const name = str(p.flags.name);
+    if (!dir || !name)
+        throw new CliError('Usage: parley deploy <built-site-dir> --name <project-name> [--project proj_…] [--summary "…"]\n  The dir must contain index.html at its root (run your build first).');
+    const root = path.resolve(dir);
+    if (!existsSync(root) || !statSync(root).isDirectory())
+        throw new CliError(`Not a directory: ${dir}`);
+    if (!existsSync(path.join(root, 'index.html')))
+        throw new CliError(`No index.html at the root of ${dir}. Point deploy at the BUILT output (dist/, build/, out/, _site/), not the source.`);
+    if (!/[a-z0-9]/i.test(name))
+        throw new CliError('--name must contain at least one letter or digit.');
+    const files = walkDir(root);
+    if (files.length === 0)
+        throw new CliError('The directory is empty.');
+    if (files.length > DEPLOY_MAX_FILES)
+        throw new CliError(`${files.length} files is over the ${DEPLOY_MAX_FILES}-file limit; deploy the built output only.`);
+    let total = 0;
+    for (const f of files)
+        total += statSync(path.join(root, f)).size;
+    if (total > DEPLOY_MAX_TOTAL_BYTES)
+        throw new CliError(`${Math.round(total / 1048576)} MB is over the ${DEPLOY_MAX_TOTAL_BYTES / 1048576} MB limit. Move large media to Parley-hosted URLs (parley image / video print them) and reference them instead of shipping them.`);
+    const project = str(p.flags.project) || `proj_site-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    if (!/^proj_[A-Za-z0-9_-]{6,}$/.test(project))
+        throw new CliError('--project must look like proj_ followed by at least six letters, digits, _ or -.');
+    // Register the workspace as one of the account's projects first: file writes
+    // accept a brand-new id, but the deploy lane proves ownership against the
+    // projects table and refuses a workspace that was never registered.
+    note(`Registering project ${project}…`);
+    await api(`/v1/projects/${project}`, { method: 'PUT', body: { name, type: 'code' } });
+    note(`Uploading ${files.length} files (${Math.round(total / 1024)} KB) into workspace ${project}…`);
+    let n = 0;
+    for (const f of files) {
+        const abs = path.join(root, f);
+        const ext = path.extname(f).slice(1).toLowerCase();
+        const mimeType = MIME[ext] || (TEXT_EXT.has(ext) ? 'text/plain' : 'application/octet-stream');
+        const isText = TEXT_EXT.has(ext) || mimeType.startsWith('text/');
+        const buf = readFileSync(abs);
+        await api(`/api/workspace/${project}/files`, {
+            body: { path: f.replace(/\\/g, '/'), content: isText ? buf.toString('utf8') : buf.toString('base64'), mimeType, isBase64: !isText, allowFullRewrite: true },
+        });
+        n++;
+        if (n % 25 === 0)
+            note(`  ${n}/${files.length}`);
+    }
+    note('Deploying…');
+    const summary = str(p.flags.summary);
+    const d = await api('/api/deploy-project', { body: { workspaceId: project, projectName: name, ...(summary ? { summary } : {}) } });
+    let url = d.url;
+    let deploymentId = d.deploymentId;
+    if (!url && d.jobId) {
+        // Asynchronous variant: poll the job until it reports a URL.
+        const deadline = Date.now() + 20 * 60 * 1000;
+        const pollMs = Number(process.env.PARLEY_POLL_MS) || 4000;
+        let last = '';
+        while (Date.now() < deadline) {
+            await sleep(pollMs);
+            const j = await api(`/api/deploy-project/jobs/${d.jobId}`);
+            const stage = j.progress?.stage || j.stage || j.status;
+            if (stage !== last) {
+                note(`  ${stage}${j.progress?.message ? ` – ${j.progress.message}` : ''}`);
+                last = stage;
+            }
+            if (j.status === 'failed' || j.ok === false)
+                throw new CliError(j.error || j.message || 'Deploy failed.');
+            url = j.url || j.result?.url;
+            deploymentId = j.deploymentId || j.result?.deploymentId;
+            if (url && (j.status === 'succeeded' || j.status === 'done' || j.status === 'complete' || j.stage === 'done'))
+                break;
+            if (url && !j.status)
+                break;
+        }
+    }
+    if (!url)
+        throw new CliError(`Deploy did not return a URL: ${JSON.stringify(d).slice(0, 200)}`);
+    emit({ ok: true, url, projectName: name, workspaceId: project, deploymentId: deploymentId ?? null, files: files.length, bytes: total }, `Live: ${url}\nWorkspace ${project} (${files.length} files). Redeploy the same site with --project ${project}.`);
 }
 /**
  * parley api <GET|POST|PATCH|PUT|DELETE> <path> [--data '<json>' | --data @file.json]
@@ -766,15 +985,16 @@ async function cmdDoctor(p) {
 function help(topic) {
     const lines = {
         doctor: 'parley doctor [--require <version>] [--json]\n  Node, server, session, credits, live engines, the @last outputs and whether a newer release exists, with the fix for anything missing. --require fails "ready" when this CLI is older than what your skills expect. Run this first.',
-        voice: `parley voice "<text>" | --file script.txt [--voice ${VOICES.join('|')}] [--quality ${VOICE_TIERS.join('|')}] [--no-fallback] [--out narration.wav]\n  Narration as a hosted WAV (natural voice 1 credit per 1,000 characters; studio 1 per 300). Becomes @last for --narration.`,
+        voice: `parley voice "<text>" | --file script.txt [--voice ${VOICES.join('|')}] [--quality ${VOICE_TIERS.join('|')}] [--split] [--no-fallback] [--out narration.wav]\n  Narration as a hosted WAV (natural voice 1 credit per 1,000 characters; studio 1 per 300). Text over 5,000 characters is split at paragraph and sentence breaks and joined back into one narration. Becomes @last for --narration.`,
         voices: 'parley voices\n  The narration personas, the tiers and their prices.',
-        studio: 'parley studio character add|cast|list · shot add|list · render <shotId> [--wait] · assemble · reels\n  The film pipeline without JSON: cast characters (identity lock), write shots ("lens look, move" camera), render, assemble a reel. Every subcommand takes --project proj_… and --json.',
+        studio: 'parley studio character add|cast|list · location add|cast|list · shot add|list · render <shotId> [--wait] · assemble · reels\n  The film pipeline without JSON: cast characters and locations (identity locks), write shots ("lens look, move" camera), render, assemble a reel. Every subcommand takes --project proj_… and --json.',
         login: 'parley login [--no-browser] [--backend URL]\n  Sign in once in your browser. --no-browser prints the link instead of opening it (cloud sandboxes, SSH). Stores a session token under ~/.parley (or $PARLEY_HOME).',
         image: `parley image "<prompt>" [--ratio ${Object.keys(RATIO_TO_SIZE).join('|')}] [--model gpt-image-2|gemini-3-pro-image-preview] [--quality low|medium|high] [--image-size 1K|2K|4K] [--ref <file|url|@last>]... [--out file]\n  Generate an image. --ratio sizes it for the destination; --ref passes reference images (identity / style locks).`,
         video: `parley video "<motion prompt>" --image <file|url|@last> [--look ${LOOKS.join('|')}] [--move <slug>]... [--duration 5] [--ratio 16:9|9:16|1:1] [--out clip.mp4]\n  Animate a still (@last = the image you just made) 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.`,
+        deploy: 'parley deploy <built-site-dir> --name <project-name> [--project proj_…] [--summary "…"]\n  Ship a built static site (index.html at the root) to a live URL on Parley\'s hosting. Reuse --project to redeploy the same site.',
         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`.',
@@ -849,6 +1069,9 @@ async function main(argv) {
             case 'api':
                 await cmdApi(p);
                 break;
+            case 'deploy':
+                await cmdDeploy(p);
+                break;
             case 'help':
             case '--help':
             case '-h':
@@ -861,10 +1084,11 @@ async function main(argv) {
     }
     catch (e) {
         const code = e instanceof CliError ? e.exitCode : 1;
+        const message = humanizeServerMessage(e?.message || String(e));
         if (JSON_MODE)
-            console.log(JSON.stringify({ ok: false, error: e?.message || String(e), code }));
+            console.log(JSON.stringify({ ok: false, error: message, code }));
         else
-            console.error(`error: ${e?.message || e}`);
+            console.error(`error: ${message}`);
         return code;
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "parley-live",
-  "version": "0.3.0",
-  "description": "Generate images, video clips with named camera moves, narration, YouTube thumbnails, product ads, complete videos and Studio films from the terminal with Parley. Built for coding agents: every command has a --json mode.",
+  "version": "0.4.1",
+  "description": "Generate images, video clips with named camera moves, narration, YouTube thumbnails, product ads, complete videos and Studio films, and deploy static sites, from the terminal with Parley. Built for coding agents: every command has a --json mode.",
   "license": "MIT",
   "type": "module",
   "bin": {