parley-live 0.3.0 → 0.4.0

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. |

package/dist/index.js

@@ -14,10 +14,10 @@
  *
  * 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.0';
 /** 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);
@@ -430,6 +430,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 +486,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 +602,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);
@@ -634,7 +726,113 @@ 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 -.');
+    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 +964,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 +1048,9 @@ async function main(argv) {
             case 'api':
                 await cmdApi(p);
                 break;
+            case 'deploy':
+                await cmdDeploy(p);
+                break;
             case 'help':
             case '--help':
             case '-h':

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.0",
+  "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": {