videobook 0.0.0-stage → 0.1.0

package/dist/openai-intelligence.js

@@ -0,0 +1,99 @@
+import { createOpenAi } from "./usage-providers.js";
+import { withRetry } from "@apicity/openai";
+export const INTELLIGENCE_MODEL = "gpt-5.6-sol";
+export const INTELLIGENCE_REASONING_EFFORT = "medium";
+export const OPENAI_ANALYSIS_TOOL = "openai_responses_analysis";
+export const ANALYSIS_REASONING_EFFORT = "high";
+export function intelligenceRequest(request, options = {}) {
+    return {
+        ...request,
+        model: options.model ?? INTELLIGENCE_MODEL,
+        reasoning: {
+            effort: options.reasoningEffort ?? INTELLIGENCE_REASONING_EFFORT,
+        },
+        store: false,
+    };
+}
+function normalizeRequest(request, options) {
+    const normalized = intelligenceRequest(request, {
+        model: options.model,
+        reasoningEffort: request.reasoning?.effort
+            ?? options.reasoningEffort
+            ?? INTELLIGENCE_REASONING_EFFORT,
+    });
+    delete normalized.temperature;
+    delete normalized.top_p;
+    return normalized;
+}
+export function buildIntelligenceResponses(apiKey, options = {}) {
+    if (!apiKey) {
+        throw new Error("OPENAI_API_KEY is not set");
+    }
+    const timeout = options.timeout ?? 180_000;
+    const provider = createOpenAi({
+        apiKey,
+        timeout,
+        ...(options.fetch ? { fetch: options.fetch } : {}),
+        ...(options.baseURL ? { baseURL: options.baseURL } : {}),
+    });
+    const call = withRetry(provider.post.v1.responses, { retries: options.retries ?? 2, baseMs: 500 });
+    return async (request, signal) => {
+        const deadline = new AbortController();
+        const timer = setTimeout(() => deadline.abort(new Error(`OpenAI Responses request exceeded ${timeout}ms`)), timeout);
+        const combinedSignal = signal
+            ? AbortSignal.any([signal, deadline.signal])
+            : deadline.signal;
+        try {
+            return await call(normalizeRequest(request, {
+                model: options.model,
+                reasoningEffort: options.reasoningEffort,
+            }), combinedSignal);
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                throw signal.reason instanceof Error
+                    ? signal.reason
+                    : new Error("OpenAI Responses request was cancelled");
+            }
+            if (deadline.signal.aborted) {
+                throw deadline.signal.reason instanceof Error
+                    ? deadline.signal.reason
+                    : new Error(`OpenAI Responses request exceeded ${timeout}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+}
+export function firstResponseText(response) {
+    if (response.error) {
+        throw new Error(`OpenAI Responses error ${response.error.code}: ${response.error.message}`);
+    }
+    if (response.status === "incomplete") {
+        const reason = response.incomplete_details?.reason ?? "unknown reason";
+        throw new Error(`OpenAI Responses output was incomplete: ${reason}`);
+    }
+    if (response.status !== "completed") {
+        throw new Error(`OpenAI Responses request did not complete (status=${response.status})`);
+    }
+    const texts = [];
+    for (const item of response.output) {
+        if (item.type !== "message")
+            continue;
+        for (const content of item.content) {
+            if (content.type === "refusal") {
+                throw new Error(`OpenAI Responses refused the request: ${content.refusal}`);
+            }
+            if (content.type === "output_text") {
+                texts.push(content.text);
+            }
+        }
+    }
+    const text = texts.join("").trim();
+    if (!text) {
+        throw new Error("OpenAI Responses returned no text content");
+    }
+    return text;
+}

package/dist/original-media-file.js

@@ -0,0 +1,12 @@
+import { findAudioFile, findPrimaryMediaFile, findVideoFile } from "videobook-engine";
+export function findOriginalMediaFile(files, kind) {
+    const originals = files.filter((file) => /^original\./i.test(file.name));
+    if (kind === "video")
+        return findVideoFile(originals);
+    if (kind === "audio") {
+        return findAudioFile(originals, kind)
+            ?? originals.find((file) => /^original\.webm$/i.test(file.name))
+            ?? null;
+    }
+    return findPrimaryMediaFile(files, kind);
+}

package/dist/osg-assets.js

@@ -0,0 +1,36 @@
+import { join, extname } from "node:path";
+const OSG_POSITIONS = [
+    "top-left", "top-center", "top-right",
+    "middle-left", "middle-center", "middle-right",
+    "bottom-left", "bottom-center", "bottom-right",
+];
+export function isOsgPosition(value) {
+    return OSG_POSITIONS.includes(value);
+}
+export function isOsgSize(value) {
+    return value === "small" || value === "medium" || value === "large";
+}
+// Wider than _image-inputs' set: OSG accepts svg since Remotion renders it in
+// a browser, while provider uploads (the _image-inputs consumers) cannot.
+const OSG_IMAGE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "gif", "svg"]);
+function findOsgImageFile(files) {
+    const images = files.filter((file) => {
+        const ext = (file.extension ?? extname(file.name)).replace(/^\./, "").toLowerCase();
+        return OSG_IMAGE_EXTENSIONS.has(ext);
+    });
+    // Manifests are alphabetically sorted, so a bare images[0] would pick a
+    // cover-crop preview variant (landscape.jpg) over the transparent source.
+    return images.find((file) => file.name.startsWith("original")) ?? images[0] ?? null;
+}
+/** Resolve an OSG image asset id to the on-disk path of its source image. */
+export async function resolveOsgImagePath(engine, osgAssetId) {
+    const manifest = await engine.files.manifest(osgAssetId);
+    if (!manifest.ok) {
+        return { ok: false, error: `OSG asset error: ${manifest.error.message}` };
+    }
+    const imgFile = findOsgImageFile(manifest.value.files);
+    if (!imgFile) {
+        return { ok: false, error: `No image file found in OSG asset ${osgAssetId}` };
+    }
+    return { ok: true, path: join(manifest.value.path, imgFile.name) };
+}

package/dist/osg-placement-cache.js

@@ -0,0 +1,64 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export const OSG_PLACEMENT_VERSION = 1;
+const OSG_PLACEMENT_METADATA_KEY = "osg.placement";
+const regionSchema = z.object({
+    kind: z.enum(["face", "text", "graphic"]),
+    confidence: z.number().min(0).max(1),
+    x: z.number().min(0).max(1),
+    y: z.number().min(0).max(1),
+    width: z.number().positive().max(1),
+    height: z.number().positive().max(1),
+}).strict().refine((region) => region.x + region.width <= 1.001 && region.y + region.height <= 1.001, { message: "occupied region extends beyond the source frame" });
+const positionSchema = z.enum([
+    "top-left", "top-center", "top-right",
+    "middle-left", "middle-center", "middle-right",
+    "bottom-left", "bottom-center", "bottom-right",
+]);
+const analysisSchema = z.object({
+    version: z.literal(OSG_PLACEMENT_VERSION),
+    fingerprint: z.string().min(1),
+    sourceWidth: z.number().positive(),
+    sourceHeight: z.number().positive(),
+    frameTimes: z.array(z.number().nonnegative()).min(1),
+    regions: z.array(regionSchema),
+    positions: z.object({
+        landscape: positionSchema,
+        portrait: positionSchema,
+        square: positionSchema,
+    }).strict(),
+    analyzedAt: z.string().min(1),
+}).strict();
+export function osgPlacementFingerprint(videoFile, frameNames, box) {
+    const payload = {
+        version: OSG_PLACEMENT_VERSION,
+        video: {
+            name: videoFile.name,
+            size: videoFile.sizeBytes,
+            objectHash: videoFile.objectHash,
+        },
+        frames: frameNames,
+        box: {
+            aspect: Number(box.aspect.toFixed(4)),
+            minDimFraction: box.minDimFraction,
+            userScale: Number(box.userScale.toFixed(2)),
+        },
+    };
+    return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+export function parseOsgPlacementAnalysis(raw) {
+    return analysisSchema.parse(raw);
+}
+export async function readOsgPlacementAnalysis(engine, assetId) {
+    const result = await engine.metadata.artifacts.read(assetId, OSG_PLACEMENT_METADATA_KEY);
+    if (!result.ok)
+        return null;
+    const parsed = analysisSchema.safeParse(result.value);
+    return parsed.success ? parsed.data : null;
+}
+export async function writeOsgPlacementAnalysis(engine, assetId, analysis) {
+    const parsed = parseOsgPlacementAnalysis(analysis);
+    const result = await engine.metadata.artifacts.write(assetId, OSG_PLACEMENT_METADATA_KEY, parsed);
+    if (!result.ok)
+        throw new Error(`Failed to persist OSG placement analysis: ${result.error.message}`);
+}

package/dist/osg-settings.js

@@ -0,0 +1,27 @@
+const ORIENTATIONS = ["landscape", "portrait", "square"];
+/**
+ * Merge OSG fields into every orientation's `.render` metadata without
+ * triggering a render. `patch` receives the orientation and its existing
+ * metadata so callers can vary fields per orientation (the frame-aware
+ * watermark stores a different corner for each) or derive defaults from the
+ * stored values.
+ */
+export async function writeOsgSettings(engine, assetId, patch) {
+    const settings = {};
+    try {
+        for (const orientation of ORIENTATIONS) {
+            const existing = await engine.metadata.artifacts.read(assetId, `${orientation}.render`);
+            const base = existing.ok ? existing.value : {};
+            settings[orientation] = { ...base, ...patch(orientation, base) };
+        }
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    for (const orientation of ORIENTATIONS) {
+        const written = await engine.metadata.artifacts.write(assetId, `${orientation}.render`, settings[orientation]);
+        if (!written.ok)
+            return { ok: false, error: written.error.message };
+    }
+    return { ok: true, settings };
+}

package/dist/paid-tools.js

@@ -0,0 +1,22 @@
+/**
+ * Tools that spend provider money: generation, analysis, transcription,
+ * tagging, and the notebook run entry points that dispatch paid cells.
+ */
+export const BILLABLE_TOOL_NAMES = new Set([
+    "prepare_cold_open", "analyze_video", "analyze_jokes", "suggest_cuts", "suggest_sfx", "apply_sfx",
+    "transcribe", "translate_subtitles", "isolate_vocals", "clean_video_audio",
+    "make_cover_song", "extend_audio_asset", "rewrite_prompt", "rewrite_script",
+    "describe_image", "analyze_image_subjects", "edit_image_subjects", "rename_all",
+    "retag_asset", "verify_x_mentions",
+    "backfill_asset_tags", "retry_generation", "retry_job",
+    "run_notebook", "run_notebook_cell", "enqueue_notebook_run", "continue_notebook_generation",
+    "generate_image", "generate_video", "generate_audio",
+]);
+/**
+ * One answer to "does running this cost the user money", shared by the workspace
+ * action catalog's confirmation policy and the chain's per-step approval gate so
+ * the two can never drift apart.
+ */
+export function toolSpendsMoney(name) {
+    return BILLABLE_TOOL_NAMES.has(name);
+}

package/dist/platform-guidance.js

@@ -0,0 +1,26 @@
+export function platformGuidance(p) {
+    switch (p) {
+        case "ig":
+            return ("PLATFORM: Instagram. Target 4:5 portrait or 1:1 square framing. " +
+                "Aesthetic-candid register — curated but unstaged: natural daylight or soft indoor light, " +
+                "warm/golden cast acceptable, light film grain tolerated. Mild VSCO-style lift in shadows; " +
+                "skin kept natural with no heavy beautify. Avoid HDR crunch, over-saturation, and harsh " +
+                "on-camera flash unless the image is clearly a flash-aesthetic shot. Default device read: " +
+                "iPhone main camera. Never use editorial/film-stock vocabulary unless the image is clearly " +
+                "a professional editorial photo.");
+        case "tiktok":
+            return ("PLATFORM: TikTok. Target 9:16 vertical framing. Raw phone snapshot energy — candid framing, " +
+                "slight motion softness, mild compression artifacts, auto-HDR lifted blacks. Indoor scenes: " +
+                "ring-light rim or warm tungsten acceptable; at night, harsh on-camera flash is on-brand. " +
+                "Front-camera selfies (with visible mirror/arm) are native to the platform. Skin unretouched, " +
+                "tiny chromatic aberration on high-contrast edges. Never apply editorial polish, cinematic " +
+                "color grading, or named film-stock vocabulary (Portra, Cinestill, etc.). No 'cinematic', " +
+                "'masterpiece', 'editorial' — this is a phone snapshot.");
+        case "youtube":
+            return ("PLATFORM: YouTube. Default to 16:9 landscape unless the image is clearly a Short (then 9:16). " +
+                "Slightly elevated production versus TikTok: punchier contrast, cleaner key light, faces " +
+                "expressive and readable at small thumbnail sizes. Colour can sit slightly saturated for " +
+                "thumbnail legibility but avoid over-stylised filters. Keep the result photographic rather " +
+                "than graphic-design; no logo overlays, no title text baked in.");
+    }
+}

package/dist/posts/dropbox-auth.js

@@ -0,0 +1,91 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { createDropbox } from "@apicity/dropbox";
+import { appState } from "../app-state.js";
+const KEY = "dropbox.oauth.tokens";
+const REDIRECT = "http://127.0.0.1:8766/callback";
+let pending = false;
+let lastError = null;
+let closeFlow = null;
+let refreshing = null;
+function oauthClient() {
+    const clientId = process.env.DROPBOX_CLIENT_ID;
+    if (!clientId)
+        throw new Error("Set DROPBOX_CLIENT_ID to your Dropbox app key before connecting");
+    return createDropbox({ clientId, clientSecret: process.env.DROPBOX_CLIENT_SECRET });
+}
+export async function dropboxClient() {
+    if (refreshing)
+        return refreshing;
+    refreshing = (async () => {
+        const tokens = await appState.get(KEY);
+        if (!tokens)
+            throw new Error("Connect Dropbox in Settings before uploading");
+        if (new Date(tokens.expiresAt).getTime() > Date.now() + 60_000)
+            return createDropbox({ oauthToken: tokens.accessToken });
+        const refreshed = await oauthClient().oauth2.token({ grant_type: "refresh_token", refresh_token: tokens.refreshToken });
+        await appState.set(KEY, { accessToken: refreshed.access_token, refreshToken: refreshed.refresh_token ?? tokens.refreshToken, expiresAt: new Date(Date.now() + refreshed.expires_in * 1000).toISOString() });
+        return createDropbox({ oauthToken: refreshed.access_token });
+    })();
+    try {
+        return await refreshing;
+    }
+    finally {
+        refreshing = null;
+    }
+}
+export async function dropboxStatus() {
+    const tokens = await appState.get(KEY);
+    return { connected: Boolean(tokens), pending, has_credentials: Boolean(process.env.DROPBOX_CLIENT_ID), error: lastError, redirect_uri: REDIRECT };
+}
+export async function startDropboxConnect() {
+    const client = oauthClient();
+    if (closeFlow)
+        throw new Error("Dropbox connection is already in progress. Complete it in the browser first.");
+    const verifier = randomBytes(32).toString("base64url");
+    const state = randomBytes(24).toString("base64url");
+    const url = new URL("https://www.dropbox.com/oauth2/authorize");
+    url.search = new URLSearchParams({ client_id: process.env.DROPBOX_CLIENT_ID, response_type: "code", redirect_uri: REDIRECT, token_access_type: "offline", code_challenge: createHash("sha256").update(verifier).digest("base64url"), code_challenge_method: "S256", state }).toString();
+    const server = createServer((req, res) => {
+        const callback = new URL(req.url ?? "/", REDIRECT);
+        if (callback.pathname !== "/callback") {
+            res.writeHead(404).end();
+            return;
+        }
+        if (callback.searchParams.get("state") !== state || !callback.searchParams.get("code")) {
+            res.writeHead(400).end("Invalid authorization callback");
+            return;
+        }
+        void (async () => {
+            try {
+                const result = await client.oauth2.token({ grant_type: "authorization_code", code: callback.searchParams.get("code"), redirect_uri: REDIRECT, code_verifier: verifier });
+                if (closeFlow !== closeCurrent) {
+                    res.writeHead(400).end("Authorization expired. Connect again from Videobook.");
+                    return;
+                }
+                if (!result.refresh_token)
+                    throw new Error("Dropbox did not grant offline access");
+                await appState.set(KEY, { accessToken: result.access_token, refreshToken: result.refresh_token, expiresAt: new Date(Date.now() + result.expires_in * 1000).toISOString() });
+                res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" }).end("Dropbox connected. Return to Videobook.");
+            }
+            catch {
+                lastError = "Dropbox authorization failed. Try connecting again.";
+                res.writeHead(400).end(lastError);
+            }
+            finally {
+                closeCurrent();
+            }
+        })();
+    });
+    const timeout = setTimeout(() => { lastError = "Dropbox connection timed out"; closeCurrent(); }, 5 * 60_000);
+    timeout.unref();
+    const closeCurrent = () => { clearTimeout(timeout); server.close(); if (closeFlow === closeCurrent) {
+        pending = false;
+        closeFlow = null;
+    } };
+    closeFlow = closeCurrent;
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(8766, "127.0.0.1", resolve); }).catch((error) => { closeCurrent(); throw error; });
+    pending = true;
+    lastError = null;
+    return { authorize_url: url.toString() };
+}

package/dist/posts/dropbox-upload.js

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { extname } from "node:path";
+import { DropboxError } from "@apicity/dropbox";
+import { dropboxClient } from "./dropbox-auth.js";
+import { freezePostOutbound, getPost, patchPostRuntime, readPostRuntime, updatePost } from "./post-store.js";
+const CHUNK = 8 * 1024 * 1024;
+export function dropboxContentHash(bytes) {
+    const hashes = [];
+    for (let offset = 0; offset < bytes.length; offset += 4 * 1024 * 1024)
+        hashes.push(createHash("sha256").update(bytes.subarray(offset, offset + 4 * 1024 * 1024)).digest());
+    return createHash("sha256").update(Buffer.concat(hashes)).digest("hex");
+}
+function correctOffset(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const object = value;
+    if (typeof object.correct_offset === "number")
+        return object.correct_offset;
+    for (const child of Object.values(object)) {
+        const result = correctOffset(child);
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+async function uploadFile(client, bytes, initial, persist, signal) {
+    let state = { ...initial };
+    const save = (patch) => { state = { ...state, ...patch }; persist(state); };
+    try {
+        const metadata = await client.files.getMetadata({ path: state.path }, signal);
+        if (metadata[".tag"] === "file" && metadata.content_hash === state.hash) {
+            save({ id: String(metadata.id), rev: String(metadata.rev), offset: bytes.length });
+            return;
+        }
+        throw new Error("The Dropbox destination already contains different content. Choose a new destination folder.");
+    }
+    catch (error) {
+        if (!(error instanceof DropboxError) || !error.error_summary?.startsWith("path/not_found"))
+            throw error;
+    }
+    if (state.rev)
+        throw new Error("A previously uploaded Dropbox file was removed. Choose a new destination folder.");
+    for (let recovery = 0; recovery < 4; recovery += 1) {
+        try {
+            if (!state.sessionId) {
+                const session = await client.files.uploadSession.start({ contents: new Uint8Array() }, signal);
+                save({ sessionId: session.session_id, offset: 0 });
+            }
+            while (state.offset < bytes.length) {
+                const end = Math.min(state.offset + CHUNK, bytes.length);
+                await client.files.uploadSession.appendV2({ contents: new Uint8Array(bytes.subarray(state.offset, end)), cursor: { session_id: state.sessionId, offset: state.offset } }, signal);
+                save({ offset: end });
+            }
+            const finished = await client.files.uploadSession.finish({ contents: new Uint8Array(), cursor: { session_id: state.sessionId, offset: state.offset }, commit: { path: state.path, mode: "add", autorename: false, mute: true, strict_conflict: true } }, signal);
+            if (finished.content_hash && finished.content_hash !== state.hash)
+                throw new Error("Dropbox returned different file content. Choose a new destination folder.");
+            save({ id: finished.id, rev: finished.rev, offset: bytes.length });
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof DropboxError))
+                throw error;
+            const offset = correctOffset(error.error);
+            if (offset !== null && offset >= 0 && offset <= bytes.length) {
+                save({ offset });
+                continue;
+            }
+            if (error.error_summary?.includes("not_found") || error.error_summary?.includes("closed") || error.error_summary?.includes("conflict")) {
+                try {
+                    const metadata = await client.files.getMetadata({ path: state.path }, signal);
+                    if (metadata[".tag"] === "file" && metadata.content_hash === state.hash) {
+                        save({ id: String(metadata.id), rev: String(metadata.rev), offset: bytes.length });
+                        return;
+                    }
+                    throw new Error("Dropbox destination content changed");
+                }
+                catch (lookup) {
+                    if (!(lookup instanceof DropboxError) || !lookup.error_summary?.startsWith("path/not_found"))
+                        throw lookup;
+                }
+                save({ sessionId: undefined, offset: 0 });
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Dropbox upload could not reconcile its saved position. Retry the upload.");
+}
+async function applyCaption(engine, id, caption) {
+    const post = getPost(engine, id);
+    if (caption === undefined || caption === post.definition.caption)
+        return post;
+    if (post.runtime.outbound)
+        throw new Error("This Post's caption was frozen at its first delivery. Create a new Post to deliver a different caption.");
+    return updatePost(engine, id, { caption });
+}
+export async function uploadPostToDropbox(engine, id, options = {}) {
+    if (["posting", "needs_reconciliation", "scheduled"].includes(getPost(engine, id).runtime.status))
+        throw new Error("Resolve or cancel the current publication before uploading");
+    const post = await applyCaption(engine, id, options.caption);
+    const outbound = await freezePostOutbound(engine, id);
+    const folder = options.folder?.replace(/\/+$/, "") ?? post.runtime.dropbox?.folder ?? `/Videobook/${engine.book.get().name}/${id}`;
+    if (!folder.startsWith("/") || folder.includes("..") || [...folder].some(character => character.charCodeAt(0) < 32))
+        throw new Error("Use an absolute Dropbox folder without .. segments");
+    const media = await engine.files.readAtRevision(outbound.artifactId, outbound.filename, outbound.revision);
+    if (!media.ok)
+        throw new Error(media.error.message);
+    const caption = Buffer.from(outbound.caption);
+    const existing = post.runtime.dropbox?.folder === folder ? post.runtime.dropbox : undefined;
+    patchPostRuntime(engine, id, { status: "uploading", error: null, dropbox: existing ?? {
+            folder,
+            video: { path: `${folder}/clip${extname(outbound.filename)}`, hash: dropboxContentHash(media.value), offset: 0 },
+            caption: { path: `${folder}/caption.txt`, hash: dropboxContentHash(caption), offset: 0 },
+        } });
+    try {
+        const client = options.client ?? await dropboxClient();
+        for (const [name, bytes] of [["video", media.value], ["caption", caption]]) {
+            const state = readPostRuntime(engine, id).dropbox;
+            await uploadFile(client, bytes, state[name], (file) => {
+                const current = readPostRuntime(engine, id).dropbox;
+                patchPostRuntime(engine, id, { dropbox: { ...current, [name]: file } });
+            }, options.signal);
+        }
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "ready", error: null, dropbox: { ...readPostRuntime(engine, id).dropbox, completedAt: new Date().toISOString() } });
+        return getPost(engine, id);
+    }
+    catch (error) {
+        const message = error instanceof DropboxError ? `Dropbox upload failed (${error.status}). ${error.status === 401 ? "Reconnect Dropbox and retry." : "Retry to resume the saved upload."}` : error instanceof Error ? error.message : "Dropbox upload failed";
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "failed", error: message });
+        throw new Error(message);
+    }
+}

package/dist/posts/icloud-drive.js

@@ -0,0 +1,134 @@
+import { createHash, randomUUID } from "node:crypto";
+import { copyFile, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, extname, join, resolve, sep } from "node:path";
+import { freezePostOutbound, getPost, patchPostRuntime, readPostRuntime, updatePost } from "./post-store.js";
+import { defaultPostFolderName, icloudFolderError } from "./post-folder.js";
+import { readUbiquitousStates, summarizeUbiquitousSync } from "./icloud-status.js";
+function icloudRoot() {
+    return process.env.VIDEOBOOK_ICLOUD_DIR || join(homedir(), "Library/Mobile Documents/com~apple~CloudDocs/Videobook");
+}
+async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileSize(path) {
+    try {
+        const info = await stat(path);
+        return info.isFile() ? info.size : -1;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function icloudUnavailableReason(root = icloudRoot()) {
+    if (process.platform !== "darwin" && !process.env.VIDEOBOOK_ICLOUD_DIR)
+        return "Saving to iCloud needs the Videobook server running on a Mac.";
+    if (!await isDirectory(dirname(root)))
+        return "iCloud Drive is not set up on this Mac. Turn on iCloud Drive in System Settings.";
+    return null;
+}
+function insideIcloudRoot(root, relativePath) {
+    const rootResolved = resolve(root);
+    const target = resolve(rootResolved, relativePath);
+    if (target !== rootResolved && !target.startsWith(`${rootResolved}${sep}`))
+        throw new Error("iCloud path is outside the Videobook folder.");
+    return target;
+}
+export async function postIcloudSyncStatus(engine, id) {
+    const recorded = getPost(engine, id).runtime.icloud;
+    const relative = [recorded?.video?.path, recorded?.caption?.path].filter((path) => Boolean(path));
+    if (relative.length === 0)
+        return { phase: "not-icloud", error: null };
+    const root = icloudRoot();
+    return summarizeUbiquitousSync(await readUbiquitousStates(relative.map((path) => insideIcloudRoot(root, path))));
+}
+export async function icloudStatus() {
+    const root = icloudRoot();
+    const reason = await icloudUnavailableReason(root);
+    const state = reason ? null : (await readUbiquitousStates([root]))?.[0] ?? null;
+    return { available: !reason, root, shared: state?.ubiquitous ? state.shared : null, role: state?.ubiquitous ? state.role : null, reason };
+}
+async function applyCaption(engine, id, caption) {
+    const post = getPost(engine, id);
+    if (caption === undefined || caption === post.definition.caption)
+        return post;
+    if (post.runtime.outbound)
+        throw new Error("This Post's caption was frozen at its first delivery. Create a new Post to deliver a different caption.");
+    return updatePost(engine, id, { caption });
+}
+async function placeFile(target, bytes) {
+    const stagingDir = join(homedir(), "Library/Caches/videobook/icloud-staging");
+    await mkdir(stagingDir, { recursive: true });
+    const staging = join(stagingDir, randomUUID());
+    await writeFile(staging, bytes);
+    try {
+        await rename(staging, target);
+    }
+    catch (error) {
+        if (!(typeof error === "object" && error !== null && "code" in error && error.code === "EXDEV"))
+            throw error;
+        const partial = join(dirname(target), `.${target.split("/").at(-1)}.videobook-partial`);
+        await copyFile(staging, partial);
+        await rename(partial, target);
+    }
+    finally {
+        await rm(staging, { force: true });
+    }
+}
+async function deliverFile(root, path, bytes, recorded) {
+    const file = { path, sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length };
+    const target = join(root, path);
+    const existing = await fileSize(target);
+    if (existing !== null) {
+        if (recorded && recorded.path === file.path && recorded.sha256 === file.sha256 && recorded.size === file.size && existing === file.size)
+            return recorded;
+        throw new Error(`iCloud folder already has a different ${path.split("/").at(-1)}. Choose another folder.`);
+    }
+    await placeFile(target, bytes);
+    return file;
+}
+export async function savePostToICloud(engine, id, options = {}) {
+    if (["posting", "needs_reconciliation", "scheduled"].includes(getPost(engine, id).runtime.status))
+        throw new Error("Resolve or cancel the current publication before saving to iCloud");
+    const root = icloudRoot();
+    const unavailable = await icloudUnavailableReason(root);
+    if (unavailable)
+        throw new Error(unavailable);
+    const current = getPost(engine, id);
+    const folder = (options.folder ?? current.runtime.icloud?.folder ?? defaultPostFolderName(engine.book.get().name, current.address, id)).trim().replace(/\/+$/u, "");
+    const folderError = icloudFolderError(folder);
+    if (folderError)
+        throw new Error(folderError);
+    const post = await applyCaption(engine, id, options.caption);
+    const outbound = await freezePostOutbound(engine, id);
+    const media = await engine.files.readAtRevision(outbound.artifactId, outbound.filename, outbound.revision);
+    if (!media.ok)
+        throw new Error(media.error.message);
+    const existing = post.runtime.icloud?.folder === folder ? post.runtime.icloud : undefined;
+    const state = existing ? { ...existing } : { folder };
+    delete state.completedAt;
+    patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "uploading", error: null, icloud: state });
+    try {
+        await mkdir(join(root, folder), { recursive: true });
+        const files = [["video", `${folder}/clip${extname(outbound.filename)}`, media.value], ["caption", `${folder}/caption.txt`, Buffer.from(outbound.caption)]];
+        for (const [name, path, bytes] of files) {
+            const delivered = await deliverFile(root, path, bytes, state[name]);
+            state[name] = delivered;
+            patchPostRuntime(engine, id, { icloud: { ...readPostRuntime(engine, id).icloud, [name]: delivered } });
+        }
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "ready", error: null, icloud: { ...readPostRuntime(engine, id).icloud, completedAt: new Date().toISOString() } });
+        return getPost(engine, id);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Saving to iCloud failed";
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "failed", error: message });
+        throw new Error(message);
+    }
+}