videobook 0.0.0-stage → 0.2.0

package/dist/tools/concat-images.js

@@ -0,0 +1,236 @@
+import sharp from "sharp";
+import { z } from "zod";
+import { cropToFill, probeImage } from "../image.js";
+import { findImageFile } from "./_image-inputs.js";
+import { derivedLabel } from "../artifact-label.js";
+const layoutOptions = ["horizontal", "vertical", "grid"];
+const aspectRatioOptions = ["16:9", "9:16", "1:1", "4:3", "3:4"];
+const concatImagesSchema = {
+    image_refs: z.array(z.string().nullable()).min(1).max(9).describe("Image artifact ids to concatenate. For a two-slot sheet, pass one id to leave the second slot empty or use null for an explicit empty slot."),
+    book_id: z.string().describe("Book id"),
+    layout: z.enum(layoutOptions).optional().describe("Cell layout. Defaults to horizontal for landscape two-slot sheets, vertical for portrait two-slot sheets, and grid for 3+ images."),
+    aspect_ratio: z.enum(aspectRatioOptions).optional().describe("Output aspect ratio. Defaults to 16:9 for video generation."),
+    name: z.string().optional().describe("Optional name for the generated image artifact"),
+    background: z.string().optional().describe("Background color for padding, e.g. #000000 or white. Defaults to #000000."),
+};
+const dimensionsByAspectRatio = {
+    "16:9": { width: 1920, height: 1080 },
+    "9:16": { width: 1080, height: 1920 },
+    "1:1": { width: 1080, height: 1080 },
+    "4:3": { width: 1440, height: 1080 },
+    "3:4": { width: 1080, height: 1440 },
+};
+export function concatImagesDef(engine) {
+    return {
+        name: "concat_images",
+        description: "Combine 1-9 image assets into one new image sheet, each fit without stretching; one or two inputs use a two-slot sheet (landscape side by side, portrait stacked).",
+        schema: concatImagesSchema,
+        handler: async (args) => {
+            const { image_refs, layout, aspect_ratio, name, background, } = args;
+            const sourceResult = await readSourceImages(engine, image_refs);
+            if (!sourceResult.ok)
+                return error(sourceResult.error);
+            if (!sourceResult.value.some((source) => source !== null)) {
+                return error("At least one image asset is required");
+            }
+            const resolvedAspectRatio = aspect_ratio ?? "16:9";
+            const resolvedLayout = layout ?? defaultLayout(resolvedAspectRatio, sourceResult.value.length);
+            const dimensions = dimensionsByAspectRatio[resolvedAspectRatio];
+            const resolvedBackground = background ?? "#000000";
+            const sourceImageIds = sourceResult.value.flatMap((source) => source ? [source.assetId] : []);
+            let output;
+            try {
+                output = await renderConcat(sourceResult.value, resolvedLayout, dimensions, resolvedBackground);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                return error(`Failed to concatenate images: ${message}`);
+            }
+            const assetName = name ?? deriveAssetName(engine, sourceImageIds);
+            const assetResult = await engine.artifacts.create("img", assetName);
+            if (!assetResult.ok)
+                return error(`Failed to create image asset: ${assetResult.error.message}`);
+            const imgAssetId = assetResult.value.artifactId;
+            const writeResult = await engine.files.write(imgAssetId, "original.png", output.buffer);
+            if (!writeResult.ok) {
+                await engine.artifacts.delete(imgAssetId).catch(() => undefined);
+                return error(writeResult.error.message);
+            }
+            const metadata = {
+                origin: "concat_images",
+                created_at: new Date().toISOString(),
+                width: output.dimensions.width,
+                height: output.dimensions.height,
+                layout: resolvedLayout,
+                aspect_ratio: resolvedAspectRatio,
+                source_images: sourceImageIds,
+            };
+            const metadataResult = await engine.metadata.artifacts.write(imgAssetId, "original", metadata);
+            if (!metadataResult.ok) {
+                await engine.artifacts.delete(imgAssetId).catch(() => undefined);
+                return error(metadataResult.error.message);
+            }
+            let variantsResult;
+            try {
+                variantsResult = await writeImageVariants(engine, imgAssetId, output.buffer);
+            }
+            catch (e) {
+                await engine.artifacts.delete(imgAssetId).catch(() => undefined);
+                const message = e instanceof Error ? e.message : String(e);
+                return error(`Failed to write image variants: ${message}`);
+            }
+            if (!variantsResult.ok) {
+                await engine.artifacts.delete(imgAssetId).catch(() => undefined);
+                return error(variantsResult.error);
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            img_asset_id: imgAssetId,
+                            asset_id: imgAssetId,
+                            filename: "original.png",
+                            width: output.dimensions.width,
+                            height: output.dimensions.height,
+                            layout: resolvedLayout,
+                            aspect_ratio: resolvedAspectRatio,
+                            source_images: sourceImageIds,
+                            placements: output.placements,
+                        }),
+                    }],
+            };
+        },
+    };
+}
+async function readSourceImages(engine, rawRefs) {
+    const sources = [];
+    for (const rawRef of rawRefs) {
+        if (rawRef === null || rawRef.trim() === "") {
+            sources.push(null);
+            continue;
+        }
+        const assetId = rawRef.replace(/^@/, "");
+        const artifact = engine.artifacts.get(assetId);
+        if (!artifact.ok)
+            return { ok: false, error: artifact.error.message };
+        if (artifact.value.kind !== "image") {
+            return { ok: false, error: `image ref must be an image artifact, got ${artifact.value.kind}: ${assetId}` };
+        }
+        const manifestResult = await engine.files.manifest(assetId);
+        if (!manifestResult.ok)
+            return { ok: false, error: manifestResult.error.message };
+        const imageFile = findImageFile(manifestResult.value.files);
+        if (!imageFile)
+            return { ok: false, error: `No image file found in asset ${assetId}` };
+        const readResult = await engine.files.read(assetId, imageFile.name);
+        if (!readResult.ok)
+            return { ok: false, error: readResult.error.message };
+        const buffer = Buffer.isBuffer(readResult.value)
+            ? readResult.value
+            : Buffer.from(readResult.value);
+        let dimensions;
+        try {
+            dimensions = await probeImage(buffer);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            return { ok: false, error: `Failed to read ${assetId}/${imageFile.name}: ${message}` };
+        }
+        if (dimensions.width <= 0 || dimensions.height <= 0) {
+            return { ok: false, error: `Could not determine dimensions for ${assetId}/${imageFile.name}` };
+        }
+        sources.push({ assetId, filename: imageFile.name, buffer });
+    }
+    return { ok: true, value: sources };
+}
+async function renderConcat(sources, layout, dimensions, background) {
+    const grid = resolveGrid(sources.length <= 2 ? 2 : sources.length, layout);
+    const composites = await Promise.all(sources.map(async (source, index) => {
+        if (!source)
+            return null;
+        const cell = cellFor(index, grid, dimensions);
+        const input = await sharp(source.buffer)
+            .rotate()
+            .resize(cell.width, cell.height, { fit: "contain", background })
+            .png()
+            .toBuffer();
+        return {
+            composite: { input, left: cell.x, top: cell.y },
+            placement: {
+                asset_id: source.assetId,
+                filename: source.filename,
+                cell,
+            },
+        };
+    }));
+    const populatedComposites = composites.filter((entry) => entry !== null);
+    const buffer = await sharp({
+        create: {
+            width: dimensions.width,
+            height: dimensions.height,
+            channels: 4,
+            background,
+        },
+    })
+        .composite(populatedComposites.map((entry) => entry.composite))
+        .png()
+        .toBuffer();
+    return {
+        buffer,
+        dimensions,
+        placements: populatedComposites.map((entry) => entry.placement),
+    };
+}
+function defaultLayout(aspectRatio, slotCount) {
+    if (slotCount > 2)
+        return "grid";
+    return aspectRatio === "9:16" || aspectRatio === "3:4" ? "vertical" : "horizontal";
+}
+function resolveGrid(count, layout) {
+    if (layout === "horizontal")
+        return { columns: count, rows: 1 };
+    if (layout === "vertical")
+        return { columns: 1, rows: count };
+    const columns = Math.ceil(Math.sqrt(count));
+    return { columns, rows: Math.ceil(count / columns) };
+}
+function cellFor(index, grid, dimensions) {
+    const column = index % grid.columns;
+    const row = Math.floor(index / grid.columns);
+    const x = Math.floor((dimensions.width * column) / grid.columns);
+    const y = Math.floor((dimensions.height * row) / grid.rows);
+    const nextX = Math.floor((dimensions.width * (column + 1)) / grid.columns);
+    const nextY = Math.floor((dimensions.height * (row + 1)) / grid.rows);
+    return {
+        x,
+        y,
+        width: nextX - x,
+        height: nextY - y,
+    };
+}
+export async function writeImageVariants(engine, assetId, buffer) {
+    const [landscape, portrait, square] = await Promise.all([
+        cropToFill(buffer, 1920, 1080),
+        cropToFill(buffer, 1080, 1920),
+        cropToFill(buffer, 1080, 1080),
+    ]);
+    const results = await Promise.all([
+        engine.files.write(assetId, "landscape.jpg", landscape),
+        engine.files.write(assetId, "portrait.jpg", portrait),
+        engine.files.write(assetId, "square.jpg", square),
+    ]);
+    const failure = results.find((result) => !result.ok);
+    if (failure && !failure.ok)
+        return { ok: false, error: failure.error.message };
+    return { ok: true };
+}
+function deriveAssetName(engine, assetIds) {
+    const sources = assetIds.map((assetId) => {
+        const artifact = engine.artifacts.get(assetId);
+        return (artifact.ok ? artifact.value.label?.trim() : "") || assetId;
+    });
+    return derivedLabel("concat", sources.join(" + "));
+}
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}

package/dist/tools/connect-service.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { dropboxStatus, startDropboxConnect } from "../posts/dropbox-auth.js";
+import { icloudStatus } from "../posts/icloud-drive.js";
+import { getOAuthFlowStatus, startOAuthFlow } from "../x/oauth-flow.js";
+function textResult(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function toolError(error) {
+    return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] };
+}
+async function startConnection(service) {
+    if (service === "x")
+        return { authorize_url: (await startOAuthFlow()).authorize_url };
+    return startDropboxConnect();
+}
+async function readStatus(service, refreshAccount) {
+    if (service === "x")
+        return getOAuthFlowStatus(undefined, { refreshAccount });
+    return service === "dropbox" ? dropboxStatus() : icloudStatus();
+}
+export function connectServiceDef() {
+    return {
+        name: "connect_service",
+        description: "Start connecting an X or Dropbox account and return the authorize_url to open; poll service_status until connected. Credentials stay in application state, outside books.",
+        scope: "global",
+        schema: { service: z.enum(["x", "dropbox"]) },
+        handler: async (args) => {
+            try {
+                return textResult(await startConnection(args.service));
+            }
+            catch (error) {
+                return toolError(error);
+            }
+        },
+    };
+}
+export function serviceStatusDef() {
+    return {
+        name: "service_status",
+        description: "Read X, Dropbox or iCloud Drive delivery status without exposing credentials. X adds the account, its subscription tier and post_max_characters; iCloud adds the Videobook root folder and whether it is shared with the phones.",
+        scope: "global",
+        schema: {
+            service: z.enum(["x", "dropbox", "icloud"]),
+            refresh_account: z.boolean().optional().describe("X only: re-read the username and subscription tier instead of the cached copy"),
+        },
+        handler: async (args) => {
+            try {
+                return textResult(await readStatus(args.service, args.refresh_account === true));
+            }
+            catch (error) {
+                return toolError(error);
+            }
+        },
+    };
+}

package/dist/tools/copy-file-to-clipboard.js

@@ -0,0 +1,58 @@
+import { exec } from "node:child_process";
+import { join } from "node:path";
+import { z } from "zod";
+import { findOriginalMediaFile } from "../original-media-file.js";
+export function copyFileToClipboardDef(engine) {
+    return {
+        name: "copy_file_to_clipboard",
+        description: "Copy an asset's original media file to the macOS pasteboard as a file reference",
+        schema: {
+            asset_id: z.string().describe("Artifact id"),
+            book_id: z.string().describe("Book UUID"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id: _book_id } = args;
+            const artifactResult = engine.artifacts.get(asset_id);
+            if (!artifactResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: artifactResult.error.message }],
+                };
+            }
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: manifestResult.error.message }],
+                };
+            }
+            const manifest = manifestResult.value;
+            const file = findOriginalMediaFile(manifest.files, artifactResult.value.kind);
+            if (!file) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "No original media file found for asset" }],
+                };
+            }
+            const absPath = join(manifest.path, file.name);
+            const fileName = file.name;
+            const escaped = absPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            const script = `set the clipboard to POSIX file "${escaped}"`;
+            return new Promise((resolve) => {
+                exec(`osascript -e '${script.replace(/'/g, "'\\''")}'`, (error) => {
+                    if (error) {
+                        resolve({
+                            isError: true,
+                            content: [{ type: "text", text: `Failed to copy to clipboard: ${error.message}` }],
+                        });
+                    }
+                    else {
+                        resolve({
+                            content: [{ type: "text", text: JSON.stringify({ status: "copied", path: absPath, file: fileName }) }],
+                        });
+                    }
+                });
+            });
+        },
+    };
+}

package/dist/tools/create-character.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { findPrimaryMediaFile } from "videobook-engine";
+import { resolveCharacterCreateName } from "../character-name.js";
+export function createCharacterDef(engine) {
+    return {
+        name: "create_character",
+        description: "Create a new character artifact, optionally seeded from existing image artifacts",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            args: z.array(z.string()).describe("Name of the character, OR one or more image artifact ids"),
+        },
+        handler: async (payload) => {
+            const { book_id: _book_id, args } = payload;
+            const imageSources = [];
+            // Parallel to imageSources: the free-text label each source carries, used
+            // as the character name stem when no explicit name is given.
+            const imageLabels = [];
+            const nameParts = [];
+            for (let arg of args) {
+                const isTagged = arg.startsWith("@");
+                if (isTagged)
+                    arg = arg.slice(1);
+                const artifact = engine.artifacts.get(arg);
+                if (artifact.ok) {
+                    if (artifact.value.kind !== "image") {
+                        return {
+                            isError: true,
+                            content: [{ type: "text", text: `Non-image source provided (${artifact.value.kind}): ${arg}` }],
+                        };
+                    }
+                    imageSources.push(arg);
+                    imageLabels.push(artifact.value.label ?? "");
+                }
+                else if (isTagged) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Unknown artifact reference: @${arg}` }],
+                    };
+                }
+                else {
+                    nameParts.push(arg);
+                }
+            }
+            if (nameParts.length === 0 && imageSources.length === 0) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Provide a name or at least one image source.` }],
+                };
+            }
+            const displayName = resolveCharacterCreateName(nameParts, imageLabels);
+            const uniqueSources = new Set(imageSources);
+            if (uniqueSources.size !== imageSources.length) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Duplicate sources provided` }],
+                };
+            }
+            const assetResult = await engine.artifacts.create("char", displayName);
+            if (!assetResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Failed to create character: ${assetResult.error.message}` }],
+                };
+            }
+            const asset_id = assetResult.value.artifactId;
+            for (let i = 0; i < imageSources.length; i++) {
+                const sourceId = imageSources[i];
+                const manifestResult = await engine.files.manifest(sourceId);
+                if (!manifestResult.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Missing source asset: ${sourceId}` }],
+                    };
+                }
+                const primaryFile = findPrimaryMediaFile(manifestResult.value.files, "image");
+                if (!primaryFile) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Source asset has no primary media: ${sourceId}` }],
+                    };
+                }
+                const ext = primaryFile.name.split(".").pop();
+                const destFilename = `source-${String(i + 1).padStart(2, "0")}.${ext}`;
+                const copyResult = await engine.files.copy(sourceId, primaryFile.name, asset_id, destFilename);
+                if (!copyResult.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Failed to copy file from ${sourceId}: ${copyResult.error.message}` }],
+                    };
+                }
+            }
+            const metaResult = await engine.metadata.artifacts.write(asset_id, "character", { display_name: displayName });
+            if (!metaResult.ok) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Created ${asset_id} but failed to write display_name: ${metaResult.error.message}`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            asset_id,
+                            display_name: displayName,
+                            message: `Created character folder ${asset_id}${imageSources.length > 0 ? ` seeded from ${imageSources.length} images` : ""}`,
+                        }),
+                    }],
+            };
+        },
+    };
+}