videobook 0.0.0-stage → 0.2.0

package/dist/tools/replace-video-audio.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { findVideoFile, findAudioFile } from "videobook-engine";
+import { probeVideo } from "../ffmpeg.js";
+export function replaceVideoAudioDef(engine) {
+    return {
+        name: "replace_video_audio",
+        description: "Replace a video's audio track in place with an audio asset, or with one file of another asset given as <artifactId>/<filename>. Existing renders become stale.",
+        schema: {
+            asset_id: z.string().describe("Video artifact whose audio is being replaced"),
+            audio_asset_id: z.string().describe("Audio source: an audio artifact id, or `<artifactId>/<filename>` to point at a specific file inside another artifact"),
+            book_id: z.string().describe("Book UUID"),
+        },
+        handler: async (args) => {
+            const { asset_id, audio_asset_id, book_id } = args;
+            const videoArtifact = engine.artifacts.get(asset_id);
+            if (!videoArtifact.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: videoArtifact.error.message }],
+                };
+            }
+            if (videoArtifact.value.kind !== "video") {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `asset_id must be a video artifact, got ${videoArtifact.value.kind} artifact ${asset_id}` }],
+                };
+            }
+            // `<artifactId>/<filename>` addresses a specific sibling file. Used by
+            // PlanViewer to splice the per-scene `plan/sN.mp3` into a freshly-
+            // generated seedance video output. Bare ids must be audio artifacts.
+            const slashIdx = audio_asset_id.indexOf("/");
+            const audioAssetIdResolved = slashIdx >= 0 ? audio_asset_id.slice(0, slashIdx) : audio_asset_id;
+            const audioFilenameOverride = slashIdx >= 0 ? audio_asset_id.slice(slashIdx + 1) : null;
+            const audioArtifact = engine.artifacts.get(audioAssetIdResolved);
+            if (!audioArtifact.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: audioArtifact.error.message }],
+                };
+            }
+            if (slashIdx < 0 && audioArtifact.value.kind !== "audio") {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `audio_asset_id must be an audio artifact or <artifactId>/<filename>, got ${audioArtifact.value.kind} artifact ${audio_asset_id}` }],
+                };
+            }
+            const videoManifest = await engine.files.manifest(asset_id);
+            if (!videoManifest.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: videoManifest.error.message }],
+                };
+            }
+            const videoFile = findVideoFile(videoManifest.value.files);
+            if (!videoFile) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `No video file found in asset ${asset_id}` }],
+                };
+            }
+            const audioManifest = await engine.files.manifest(audioAssetIdResolved);
+            if (!audioManifest.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: audioManifest.error.message }],
+                };
+            }
+            let audioFileName;
+            if (audioFilenameOverride !== null) {
+                const file = audioManifest.value.files.find((f) => f.name === audioFilenameOverride);
+                if (!file) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `File ${audioFilenameOverride} not found in asset ${audioAssetIdResolved}` }],
+                    };
+                }
+                audioFileName = file.name;
+            }
+            else {
+                const file = findAudioFile(audioManifest.value.files, audioArtifact.value.kind);
+                if (!file) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `No audio file found in asset ${audioAssetIdResolved}` }],
+                    };
+                }
+                audioFileName = file.name;
+            }
+            const assetDir = videoManifest.value.path;
+            const videoPath = join(assetDir, videoFile.name);
+            const audioPath = join(audioManifest.value.path, audioFileName);
+            try {
+                const [video, audio] = await Promise.all([probeVideo(videoPath), probeVideo(audioPath)]);
+                if (!video.videoStream || video.videoDuration <= 0)
+                    throw new Error("Video source has no playable video stream");
+                if (!audio.hasAudio || (audio.audioDuration ?? audio.duration) <= 0)
+                    throw new Error("Replacement source has no playable audio stream");
+            }
+            catch (error) {
+                return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] };
+            }
+            const tempPath = join(assetDir, "original_audio_replaced.mp4");
+            const jobId = `replace-audio-${asset_id}-${Date.now()}`;
+            try {
+                await queue.enqueueAndWait(jobId, {
+                    type: "replace_video_audio",
+                    inputPath: videoPath,
+                    audioPath,
+                    outputPath: tempPath,
+                    assetId: asset_id,
+                    assetDir,
+                    audioAssetId: audio_asset_id,
+                    bookId: book_id,
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Replace audio failed: ${msg}` }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id, audio_asset_id, job_id: jobId, status: "completed" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/restore-archive-clips.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { extname } from "node:path";
+import { indexKey } from "../archive-b2.js";
+import { getArchiveStore } from "../archive-store.js";
+import { queue } from "../queue.js";
+const MAX_RESTORE_IDS = 25;
+const ARCHIVE_ID_RE = /^[a-f0-9]{64}$/i;
+const EXTENSION_TARGETS = new Map([
+    [".mp4", { kind: "video" }],
+    [".mov", { kind: "video" }],
+    [".webm", { kind: "video" }],
+    [".mkv", { kind: "video" }],
+    [".mp3", { kind: "audio" }],
+    [".wav", { kind: "audio" }],
+    [".m4a", { kind: "audio" }],
+    [".aac", { kind: "audio" }],
+    [".flac", { kind: "audio" }],
+    [".ogg", { kind: "audio" }],
+    [".weba", { kind: "audio" }],
+]);
+const CONTENT_TYPE_EXTENSIONS = new Map([
+    ["video/mp4", ".mp4"],
+    ["video/quicktime", ".mov"],
+    ["video/webm", ".webm"],
+    ["video/x-matroska", ".mkv"],
+    ["audio/mpeg", ".mp3"],
+    ["audio/wav", ".wav"],
+    ["audio/mp4", ".m4a"],
+    ["audio/aac", ".aac"],
+    ["audio/flac", ".flac"],
+    ["audio/ogg", ".ogg"],
+    ["audio/webm", ".weba"],
+]);
+function toolError(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+function normalizeArchiveIds(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const id = value.trim().toLowerCase();
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+function archiveMediaTarget(index) {
+    const filenameExtension = extname(index.media.filename).toLowerCase();
+    const contentType = index.media.content_type.toLowerCase().split(";")[0]?.trim() ?? "";
+    const contentTypeExtension = CONTENT_TYPE_EXTENSIONS.get(contentType) || "";
+    const extension = filenameExtension === ".webm" && contentTypeExtension === ".weba"
+        ? ".weba"
+        : EXTENSION_TARGETS.has(filenameExtension) ? filenameExtension : contentTypeExtension;
+    const target = EXTENSION_TARGETS.get(extension);
+    if (!target)
+        return null;
+    return {
+        ...target,
+        filename: `original${extension}`,
+    };
+}
+function archiveAssetName(index) {
+    const title = index.title?.trim();
+    if (title)
+        return title;
+    const base = index.media.filename.replace(/\.[^.]+$/, "").trim();
+    return base || `archive ${index.archive_id.slice(0, 8)}`;
+}
+function tagLabels(tags) {
+    return tags.map((tag) => tag.label);
+}
+function archiveMetadata(index) {
+    return {
+        archive_id: index.archive_id,
+        sha256: index.sha256,
+        title: index.title,
+        media_key: index.media.key,
+        media_filename: index.media.filename,
+        media_content_type: index.media.content_type,
+        media_size_bytes: index.media.size_bytes,
+        archive_created_at: index.created_at,
+        archive_updated_at: index.updated_at,
+        archived_at: index.created_at,
+        restored_at: new Date().toISOString(),
+        topics: tagLabels(index.topics),
+        people: tagLabels(index.people),
+    };
+}
+async function existingArchiveAssets(engine, archiveIds) {
+    const wanted = new Set(archiveIds);
+    const out = new Map();
+    const assets = await engine.artifacts.list();
+    await Promise.all(assets.map(async (asset) => {
+        const meta = await engine.metadata.artifacts.read(asset.artifactId, "archive");
+        if (!meta.ok)
+            return;
+        const archiveId = meta.value.archive_id;
+        if (typeof archiveId === "string" && wanted.has(archiveId)) {
+            out.set(archiveId, asset.artifactId);
+        }
+    }));
+    return out;
+}
+export function restoreArchiveClipsDef(engine) {
+    return {
+        name: "restore_archive_clips",
+        description: "Restore selected archived video/audio clips into the current Videobook as new assets.",
+        schema: {
+            book_id: z.string().describe("Book id to restore clips into"),
+            archive_ids: z.array(z.string()).min(1).max(MAX_RESTORE_IDS).describe("Archive IDs to restore"),
+            skip_existing: z.boolean().optional().default(true).describe("Skip archive IDs already restored into this project"),
+        },
+        handler: async (args) => {
+            const { book_id, archive_ids, skip_existing } = args;
+            const archiveIds = normalizeArchiveIds(archive_ids);
+            if (archiveIds.length === 0)
+                return toolError("restore_archive_clips requires at least one archive_id");
+            if (archiveIds.length > MAX_RESTORE_IDS)
+                return toolError(`restore_archive_clips supports at most ${MAX_RESTORE_IDS} archive_ids`);
+            const invalid = archiveIds.filter((id) => !ARCHIVE_ID_RE.test(id));
+            if (invalid.length > 0)
+                return toolError(`Invalid archive_id: ${invalid.join(", ")}`);
+            const store = getArchiveStore();
+            const indices = [];
+            for (const archiveId of archiveIds) {
+                const index = await store.getJson(indexKey(store, archiveId));
+                if (!index)
+                    return toolError(`Archive clip not found: ${archiveId}`);
+                indices.push(index);
+            }
+            const existing = skip_existing
+                ? await existingArchiveAssets(engine, indices.map((index) => index.archive_id))
+                : new Map();
+            const targets = new Map();
+            for (const index of indices) {
+                if (existing.has(index.archive_id))
+                    continue;
+                const target = archiveMediaTarget(index);
+                if (!target)
+                    return toolError(`Archive media type is not supported: ${index.media.filename}`);
+                targets.set(index.archive_id, target);
+            }
+            const restored = [];
+            const skipped = [];
+            for (const index of indices) {
+                const existingAssetId = existing.get(index.archive_id);
+                if (existingAssetId) {
+                    skipped.push({ archive_id: index.archive_id, asset_id: existingAssetId, reason: "already_restored" });
+                    continue;
+                }
+                const target = targets.get(index.archive_id);
+                const created = await engine.artifacts.create(target.kind, archiveAssetName(index));
+                if (!created.ok)
+                    return toolError(created.error.message);
+                const writeArchive = await engine.metadata.artifacts.write(created.value.artifactId, "archive", archiveMetadata(index));
+                if (!writeArchive.ok) {
+                    await engine.artifacts.delete(created.value.artifactId).catch(() => undefined);
+                    return toolError(writeArchive.error.message);
+                }
+                const jobId = `restore-archive-${created.value.artifactId}-${Date.now()}`;
+                try {
+                    await queue.enqueue(jobId, {
+                        type: "restore_archive_clip",
+                        bookId: book_id,
+                        assetId: created.value.artifactId,
+                        assetDir: created.value.path,
+                        archiveId: index.archive_id,
+                        mediaKey: index.media.key,
+                        filename: target.filename,
+                        contentType: index.media.content_type,
+                        mediaKind: target.kind,
+                        title: index.title,
+                        duration: index.duration,
+                        topics: tagLabels(index.topics),
+                        people: tagLabels(index.people),
+                    });
+                }
+                catch (error) {
+                    await engine.artifacts.delete(created.value.artifactId).catch(() => undefined);
+                    return toolError(error instanceof Error ? error.message : String(error));
+                }
+                restored.push({
+                    archive_id: index.archive_id,
+                    asset_id: created.value.artifactId,
+                    job_id: jobId,
+                });
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            status: restored.length > 0 ? "enqueued" : "noop",
+                            restored,
+                            skipped,
+                        }),
+                    }],
+            };
+        },
+    };
+}
+export const __restoreArchiveClipsTest = {
+    archiveMediaTarget,
+    normalizeArchiveIds,
+};

package/dist/tools/restore-asset-version.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export function restoreAssetVersionDef(engine) {
+    return {
+        name: "restore_asset_version",
+        description: "Restore an asset from an immutable revision as a new revision",
+        schema: {
+            asset_id: z
+                .string()
+                .describe("Stable artifact UUID, or the slug of an active artifact"),
+            commit_hash: z.string().describe("DoltLite revision hash to restore from"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, commit_hash } = args;
+            const artifact = engine.artifacts.get(asset_id);
+            const artifactId = artifact.ok ? artifact.value.artifactId : asset_id;
+            const restored = await engine.history.restoreArtifact(artifactId, commit_hash);
+            if (!restored.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: restored.error.message }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            status: "restored",
+                            asset_id: artifactId,
+                            from_commit: commit_hash,
+                            new_commit: restored.value.hash,
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/retry-generation.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { queue } from "../queue.js";
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+/** Replay a failed generation using its persisted `generation-request` payload.
+ *  Clears the error row (reverting the asset to claimable `pending`) and
+ *  re-enqueues the exact job, so the queue's generate_* handoff re-claims the
+ *  SAME asset. Safe because generationErrors.clear is CAS-revertible. */
+export function retryGenerationDef(engine) {
+    return {
+        name: "retry_generation",
+        description: "Re-run a failed generation with its original request payload and inputs, clearing the asset's error first.",
+        schema: {
+            asset_id: z.string().describe("Asset ID of the failed generation to retry (vid-*, or @-prefixed)"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id: _book_id } = args;
+            const assetId = asset_id.replace(/^@/, "");
+            const metaResult = await engine.metadata.artifacts.read(assetId, "generation-request");
+            if (!metaResult.ok || metaResult.value === null) {
+                return error(`No generation-request metadata found for ${assetId} — cannot retry. Recover or regenerate instead.`);
+            }
+            const payload = metaResult.value;
+            const type = typeof payload.type === "string" ? payload.type : "";
+            if (type !== "generate_media") {
+                return error(`Stored generation-request for ${assetId} is not a replayable generation (type: ${type || "unknown"}); regenerate it with generate_image, generate_video or generate_audio`);
+            }
+            const embeddedId = typeof payload.assetId === "string" ? payload.assetId : null;
+            if (embeddedId !== assetId) {
+                return error(`generation-request payload targets a different asset (${embeddedId ?? "none"}) than ${assetId}`);
+            }
+            // Refuse if an active task is already in flight for this asset.
+            const taskResult = await engine.jobs.pending.read(assetId);
+            const activeTask = taskResult.ok ? taskResult.value : null;
+            if (activeTask !== null) {
+                return error(`${assetId} already has an active generation in progress (task ${activeTask.taskId})`);
+            }
+            const cleared = await engine.jobs.failures.clear(assetId);
+            if (!cleared.ok) {
+                return error(`Failed to clear error for ${assetId}: ${cleared.error.message}`);
+            }
+            const jobId = `retry-${assetId}-${Date.now()}`;
+            await queue.enqueue(jobId, payload);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id: assetId, retried: true, job_id: jobId }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/reverse-video.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { getFFmpeggy } from "../ffmpeg.js";
+import { findVideoFile } from "videobook-engine";
+const MAX_DURATION_SECONDS = 300;
+async function hasAudioStream(filePath) {
+    const FFmpeggy = await getFFmpeggy();
+    const probe = await FFmpeggy.probe(filePath);
+    return probe.streams.some((s) => s.codec_type === "audio");
+}
+async function getVideoDuration(filePath) {
+    const FFmpeggy = await getFFmpeggy();
+    const probe = await FFmpeggy.probe(filePath);
+    return parseFloat(probe.format.duration);
+}
+export function reverseVideoDef(engine) {
+    return {
+        name: "reverse_video",
+        description: "Reverse video playback (play backwards). Toggle operation — reversing twice restores original. Max 300s due to memory buffering.",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. vid-my-video)"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id } = args;
+            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 videoFile = findVideoFile(manifest.files);
+            if (!videoFile) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `No video file found in asset ${asset_id}` }],
+                };
+            }
+            const assetDir = manifest.path;
+            const videoPath = join(assetDir, videoFile.name);
+            const duration = await getVideoDuration(videoPath);
+            if (duration > MAX_DURATION_SECONDS) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Video is ${duration.toFixed(1)}s — reverse requires buffering all frames in memory. Maximum supported duration is ${MAX_DURATION_SECONDS}s (5 minutes). Trim the video first.`,
+                        }],
+                };
+            }
+            const hasAudio = await hasAudioStream(videoPath);
+            const tempPath = join(assetDir, "original_reversed.mp4");
+            const jobId = `reverse-${asset_id}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "reverse_video",
+                inputPath: videoPath,
+                outputPath: tempPath,
+                hasAudio,
+                assetId: asset_id,
+                assetDir,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id, job_id: jobId, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}