videobook 0.0.0-stage → 0.2.0

package/dist/scheduled-posts.js

@@ -0,0 +1,200 @@
+import { patchPostRuntime, readPostRuntime } from "./posts/post-store.js";
+import { randomUUID } from "node:crypto";
+import { logger } from "./logger.js";
+import { listBookEngines, queue, resolveBookEngine, } from "./queue.js";
+const REARM_INTERVAL_MS = 12 * 60 * 60_000;
+const SAFE_TIMEOUT_MS = 2_147_483_000;
+export const SCHEDULED_POST_SETTINGS_KEY = "application.scheduled_posts.v1";
+const armed = new Map();
+let writeChain = Promise.resolve();
+let rearmInterval = null;
+function serialize(fn) {
+    const next = writeChain.then(fn, fn);
+    writeChain = next.catch(() => { });
+    return next;
+}
+function readState(engine) {
+    const entries = engine.settings.get(SCHEDULED_POST_SETTINGS_KEY);
+    return Array.isArray(entries) ? entries : [];
+}
+function writeState(engine, entries) {
+    const result = engine.settings.set(SCHEDULED_POST_SETTINGS_KEY, entries);
+    if (!result.ok)
+        throw new Error(result.error.message);
+}
+async function updateEntry(bookId, scheduleId, patch) {
+    await serialize(async () => {
+        const engine = await resolveBookEngine(bookId);
+        const entries = readState(engine);
+        const updated = entries.map((entry) => entry.schedule_id === scheduleId ? { ...entry, ...patch } : entry);
+        writeState(engine, updated);
+    });
+}
+function timerKey(bookId, scheduleId) {
+    return `${bookId}:${scheduleId}`;
+}
+function armTimer(bookId, entry) {
+    const key = timerKey(bookId, entry.schedule_id);
+    if (armed.has(key))
+        return;
+    if (entry.status !== "pending")
+        return;
+    const delay = new Date(entry.scheduled_for).getTime() - Date.now();
+    const safeDelay = Math.min(Math.max(delay, 0), SAFE_TIMEOUT_MS);
+    if (delay > SAFE_TIMEOUT_MS) {
+        return;
+    }
+    const t = setTimeout(() => {
+        armed.delete(key);
+        void firePost(bookId, entry.schedule_id).catch((e) => logger.error("scheduled-post-failed", { bookId, scheduleId: entry.schedule_id, error: e }));
+    }, safeDelay);
+    armed.set(key, t);
+}
+async function firePost(bookId, scheduleId) {
+    const engine = await resolveBookEngine(bookId);
+    const entries = readState(engine);
+    const entry = entries.find((e) => e.schedule_id === scheduleId);
+    if (!entry || entry.status !== "pending")
+        return;
+    const jobId = `post-x-${scheduleId}`;
+    try {
+        const result = await queue.enqueueAndWait(jobId, {
+            type: "post_to_x",
+            assetId: entry.payload.asset_id,
+            postCellId: entry.payload.post_cell_id,
+            bookId: entry.payload.book_id,
+            text: entry.payload.text,
+            orientation: entry.payload.orientation,
+            scheduleId,
+            scheduledFor: entry.scheduled_for,
+            followups: entry.payload.followups,
+        });
+        await updateEntry(bookId, scheduleId, {
+            status: result.status,
+            tweet_id: result.tweet_id,
+            tweet_url: result.tweet_url,
+            replies: result.replies,
+            followup_error: result.followup_error,
+            ...(result.followup_error ? { error: result.followup_error.message } : {}),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await updateEntry(bookId, scheduleId, { status: "failed", error: message });
+    }
+}
+export async function schedulePost(payload, scheduledFor) {
+    const when = new Date(scheduledFor);
+    if (Number.isNaN(when.getTime())) {
+        throw new Error(`Invalid scheduled_for: ${scheduledFor}`);
+    }
+    const engine = await resolveBookEngine(payload.book_id);
+    if (payload.post_cell_id) {
+        const current = readPostRuntime(engine, payload.post_cell_id);
+        if (current.url || ["posting", "needs_reconciliation"].includes(current.status))
+            throw new Error("This Post is already published or needs reconciliation");
+        if (current.status === "scheduled" && current.scheduleId) {
+            if (current.scheduledFor === when.toISOString())
+                return { schedule_id: current.scheduleId, scheduled_for: current.scheduledFor };
+            await cancelScheduledPost(current.scheduleId);
+        }
+    }
+    const entry = {
+        schedule_id: randomUUID(),
+        payload,
+        scheduled_for: when.toISOString(),
+        created_at: new Date().toISOString(),
+        status: "pending",
+    };
+    await serialize(async () => {
+        const entries = readState(engine);
+        entries.push(entry);
+        writeState(engine, entries);
+    });
+    if (payload.post_cell_id)
+        patchPostRuntime(engine, payload.post_cell_id, { status: "scheduled", scheduledFor: entry.scheduled_for, scheduleId: entry.schedule_id });
+    armTimer(payload.book_id, entry);
+    return { schedule_id: entry.schedule_id, scheduled_for: entry.scheduled_for };
+}
+export async function cancelScheduledPost(scheduleId) {
+    let found = false;
+    const engines = await listBookEngines();
+    await serialize(async () => {
+        for (const engine of engines) {
+            const bookId = engine.book.get().bookId;
+            const entries = readState(engine);
+            let changed = false;
+            const updated = entries.map((entry) => {
+                if (entry.schedule_id !== scheduleId || entry.status !== "pending") {
+                    return entry;
+                }
+                found = true;
+                if (entry.payload.post_cell_id)
+                    patchPostRuntime(engine, entry.payload.post_cell_id, { status: "draft", scheduledFor: undefined, scheduleId: undefined });
+                changed = true;
+                return { ...entry, status: "cancelled" };
+            });
+            if (!changed)
+                continue;
+            const key = timerKey(bookId, scheduleId);
+            const timer = armed.get(key);
+            if (timer)
+                clearTimeout(timer);
+            armed.delete(key);
+            writeState(engine, updated);
+        }
+    });
+    return found;
+}
+export async function listScheduledPosts() {
+    const engines = await listBookEngines();
+    return engines
+        .flatMap((engine) => readState(engine))
+        .sort((left, right) => left.created_at.localeCompare(right.created_at));
+}
+export async function loadAndArmAll() {
+    const now = Date.now();
+    const engines = await listBookEngines();
+    for (const engine of engines) {
+        const bookId = engine.book.get().bookId;
+        for (const entry of readState(engine)) {
+            if (entry.status !== "pending")
+                continue;
+            const due = new Date(entry.scheduled_for).getTime();
+            if (due <= now) {
+                void firePost(bookId, entry.schedule_id).catch((e) => logger.error("scheduled-post-failed", { bookId, scheduleId: entry.schedule_id, error: e }));
+            }
+            else {
+                armTimer(bookId, entry);
+            }
+        }
+    }
+    if (!rearmInterval) {
+        rearmInterval = setInterval(() => {
+            void rearmPending().catch((e) => logger.error("scheduled-post-rearm-failed", { error: e }));
+        }, REARM_INTERVAL_MS);
+        rearmInterval.unref?.();
+    }
+}
+async function rearmPending() {
+    const engines = await listBookEngines();
+    for (const engine of engines) {
+        const bookId = engine.book.get().bookId;
+        for (const entry of readState(engine)) {
+            if (entry.status !== "pending")
+                continue;
+            if (armed.has(timerKey(bookId, entry.schedule_id)))
+                continue;
+            armTimer(bookId, entry);
+        }
+    }
+}
+export function stopScheduler() {
+    for (const t of armed.values())
+        clearTimeout(t);
+    armed.clear();
+    if (rearmInterval) {
+        clearInterval(rearmInterval);
+        rearmInterval = null;
+    }
+}

package/dist/search-index-coverage.js

@@ -0,0 +1,13 @@
+import { LOCAL_CLIP_MANIFEST } from "videobook-engine";
+export function missingVisualIndexes(engine, assets) {
+    return assets.filter((asset) => {
+        if (asset.status !== "ready" || !["image", "video", "final"].includes(asset.type))
+            return false;
+        if (!asset.object_hash)
+            return true;
+        const plan = engine.temporalSearch.plan(asset.artifact_id, asset.object_hash, LOCAL_CLIP_MANIFEST.manifestId, LOCAL_CLIP_MANIFEST.manifestId);
+        if (!plan.ok)
+            return true;
+        return !plan.value.coverage.some((entry) => entry.phase === "visual" && entry.state === "ready" && entry.indexedUnits > 0);
+    });
+}

package/dist/search-index-media.js

@@ -0,0 +1,71 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { findVideoFile } from "videobook-engine";
+import { probeVideo, runFfmpeg } from "./ffmpeg.js";
+import { formatTimestamp, generateTimestamps } from "./frame-utils.js";
+import { registerMediaStreams } from "./jobs/process-video.js";
+async function prepareSearchFrames(engine, artifactId, signal) {
+    const streams = engine.streams.list(artifactId);
+    if (!streams.ok)
+        throw new Error(streams.error.message);
+    const manifest = await engine.files.manifest(artifactId);
+    if (!manifest.ok)
+        throw Object.assign(new Error(manifest.error.message), { name: manifest.error.code, error: manifest.error });
+    const video = streams.value.find((stream) => stream.kind === "video"
+        && manifest.value.files.some((file) => file.name === stream.sourcePath && file.objectHash === stream.objectHash));
+    if (!video)
+        return;
+    const marker = await engine.metadata.artifacts.read(artifactId, "migrationFrames");
+    if (!marker.ok && marker.error.code !== "NOT_FOUND")
+        throw new Error(marker.error.message);
+    if (marker.ok && marker.value.objectHash !== video.objectHash)
+        throw new Error("Video changed before its search frames were prepared");
+    if (!marker.ok && manifest.value.files.some((file) => /^original_frames\/\d+(?:\.\d+)?\.jpg$/u.test(file.name)))
+        return;
+    const duration = video.durationTicks * video.timeBase.numerator / video.timeBase.denominator;
+    const frames = marker.ok ? marker.value.frames : generateTimestamps(duration).map((time) => `original_frames/${formatTimestamp(time)}.jpg`);
+    if (!marker.ok) {
+        const written = await engine.metadata.artifacts.write(artifactId, "migrationFrames", { objectHash: video.objectHash, frames });
+        if (!written.ok)
+            throw new Error(written.error.message);
+    }
+    const existing = new Set(manifest.value.files.map((file) => file.name));
+    const temporary = await mkdtemp(join(tmpdir(), "videobook-search-frames-"));
+    try {
+        for (const name of frames) {
+            signal?.throwIfAborted();
+            if (!/^original_frames\/\d+(?:\.\d+)?\.jpg$/u.test(name))
+                throw new Error("Invalid search frame record");
+            if (existing.has(name))
+                continue;
+            const target = join(temporary, "frame.jpg");
+            await runFfmpeg(["-y", "-ss", name.slice("original_frames/".length, -4),
+                "-i", join(manifest.value.path, video.sourcePath), "-map", `0:${video.streamIndex}`, "-frames:v", "1", "-q:v", "2", target], { signal });
+            const written = await engine.files.write(artifactId, name, await readFile(target));
+            if (!written.ok)
+                throw new Error(written.error.message);
+        }
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true, maxRetries: 3 });
+    }
+}
+export async function prepareSearchVideo(engine, artifactId, signal) {
+    const manifest = await engine.files.manifest(artifactId);
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const file = findVideoFile(manifest.value.files);
+    if (!file)
+        throw new Error("No video source is available for indexing");
+    const streams = engine.streams.list(artifactId);
+    if (!streams.ok)
+        throw new Error(streams.error.message);
+    if (!streams.value.some((stream) => stream.kind === "video" && stream.objectHash === file.objectHash)) {
+        const probe = await probeVideo(join(manifest.value.path, file.name), { signal });
+        if (!probe.videoStream)
+            throw new Error("No usable video stream is available for indexing");
+        await registerMediaStreams(engine, artifactId, file.name, probe);
+    }
+    await prepareSearchFrames(engine, artifactId, signal);
+}

package/dist/search-reference-store.js

@@ -0,0 +1,60 @@
+import { v7 as uuidv7 } from "uuid";
+export class SearchReferenceStore {
+    entries = new Map();
+    ttlMs;
+    maxEntries;
+    now;
+    constructor(ttlMs = 30 * 60_000, maxEntries = 128, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+        this.now = now;
+    }
+    put(input) {
+        this.purge();
+        while (this.entries.size >= this.maxEntries) {
+            const oldest = this.entries.keys().next().value;
+            if (typeof oldest !== "string")
+                break;
+            this.entries.delete(oldest);
+        }
+        const referenceId = uuidv7();
+        const descriptor = {
+            reference_id: referenceId,
+            kind: input.kind,
+            name: input.name,
+            ...(input.durationMs === undefined
+                ? {}
+                : { duration_ms: input.durationMs }),
+            expires_at: this.now() + this.ttlMs,
+            ...(input.preview ? { preview_url: `/api/search-references/${referenceId}/preview` } : {}),
+        };
+        this.entries.set(referenceId, {
+            descriptor,
+            reference: input.reference,
+            ...(input.preview ? { preview: input.preview } : {}),
+        });
+        return descriptor;
+    }
+    get(referenceId) {
+        this.purge();
+        const entry = this.entries.get(referenceId);
+        if (!entry) {
+            throw new Error("Search reference expired or was released");
+        }
+        this.entries.delete(referenceId);
+        this.entries.set(referenceId, entry);
+        return entry;
+    }
+    release(referenceId) {
+        return this.entries.delete(referenceId);
+    }
+    purge() {
+        const now = this.now();
+        for (const [referenceId, entry] of this.entries) {
+            if (entry.descriptor.expires_at <= now) {
+                this.entries.delete(referenceId);
+            }
+        }
+    }
+}
+export const searchReferenceStore = new SearchReferenceStore();

package/dist/search-scoring.js

@@ -0,0 +1,17 @@
+// Engine hit scores are reciprocal-rank values, so they only order hits within
+// a single book. Ranking across books must use the per-signal similarity
+// scores, which are comparable because every book shares the same embedding
+// spaces; exact and near fingerprint matches outrank any similarity.
+export function comparableHitScore(hit) {
+    let boost = 0;
+    let strongest = 0;
+    for (const signal of hit.signals) {
+        if (signal.kind === "exact")
+            boost = Math.max(boost, 1);
+        else if (signal.kind === "near")
+            boost = Math.max(boost, 0.25);
+        else
+            strongest = Math.max(strongest, Math.min(signal.score ?? 0, 1));
+    }
+    return Math.min(boost + strongest, 1);
+}

package/dist/serve.js

@@ -0,0 +1,125 @@
+import { once } from "node:events";
+import { setTimeout as delay } from "node:timers/promises";
+import { stopAceServer } from "./acestep/process.js";
+import { createApp } from "./app.js";
+import { bookManager, scopedEngine } from "./engine.js";
+import { getDefaultSecretStore } from "./env-secrets.js";
+import { hydrateLibrary } from "./hydration.js";
+import { registerAllJobHandlers } from "./jobs/index.js";
+import { logger } from "./logger.js";
+import { stopPostMetricsScheduler } from "./posts/post-metrics.js";
+import { queue } from "./queue.js";
+import { stopScheduler } from "./scheduled-posts.js";
+import { SERVER_VERSION } from "./server.js";
+import { ServerAlreadyRunningError, acquireServerLock, inspectServerOwner, } from "./server-lock.js";
+import { attachVoiceAudio } from "./voice-audio.js";
+const LOOPBACK_HOST = "127.0.0.1";
+const SHUTDOWN_WATCHDOG_MS = 20_000;
+const HTTP_CLOSE_GRACE_MS = 2_000;
+async function shutdownServices(services) {
+    stopScheduler();
+    stopPostMetricsScheduler();
+    await services.voiceSessions.close();
+    await services.mcpHandler.close();
+    await queue.stop();
+    await stopAceServer();
+    await bookManager.close();
+}
+async function finishHttpClose(server, closed) {
+    server.closeAllConnections();
+    await Promise.race([closed, delay(HTTP_CLOSE_GRACE_MS, undefined, { ref: false })]);
+}
+function closer(server, services, lock, onClosing) {
+    let closing;
+    async function run() {
+        onClosing();
+        const closed = new Promise((resolveClose) => server.close(() => resolveClose()));
+        try {
+            await shutdownServices(services);
+            logger.info("shutdown-complete");
+        }
+        catch (error) {
+            logger.error("shutdown-failed", { error });
+            throw error;
+        }
+        finally {
+            await finishHttpClose(server, closed);
+            await lock.release();
+        }
+    }
+    return () => {
+        closing ??= run();
+        return closing;
+    };
+}
+function boundPort(server, fallback) {
+    const address = server.address();
+    return address && typeof address !== "string" ? address.port : fallback;
+}
+function startHydration(isClosing) {
+    const ready = hydrateLibrary(bookManager, {
+        devFixtures: process.env.VIDEOBOOK_DEV_FIXTURES === "1",
+    }).catch((error) => {
+        if (!isClosing())
+            throw error;
+    });
+    ready.catch(() => undefined);
+    return ready;
+}
+async function refuseRunningOwner(libraryDir) {
+    const owner = await inspectServerOwner(libraryDir);
+    if (owner.kind === "none")
+        return;
+    throw new ServerAlreadyRunningError(owner.record, libraryDir, owner.kind === "running");
+}
+async function claimLibrary(server, libraryDir, port, url) {
+    try {
+        return await acquireServerLock(libraryDir, { pid: process.pid, port, url, version: SERVER_VERSION });
+    }
+    catch (error) {
+        await new Promise((resolveClose) => server.close(() => resolveClose()));
+        throw error;
+    }
+}
+export async function startServer(options) {
+    const libraryDir = bookManager.rootDir;
+    await refuseRunningOwner(libraryDir);
+    getDefaultSecretStore().resolveOnePassword();
+    registerAllJobHandlers(scopedEngine);
+    const services = createApp({ ui: options.ui, uiDir: options.uiDir });
+    const server = services.app.listen(options.port, LOOPBACK_HOST);
+    await once(server, "listening");
+    const port = boundPort(server, options.port);
+    const url = `http://${LOOPBACK_HOST}:${port}`;
+    const lock = await claimLibrary(server, libraryDir, port, url);
+    logger.info("server-listening", { port });
+    attachVoiceAudio(server, services.voiceSessions);
+    let closing = false;
+    const close = closer(server, services, lock, () => {
+        closing = true;
+    });
+    return {
+        port,
+        url,
+        mcpUrl: `${url}/mcp`,
+        libraryDir,
+        uiDir: services.uiDir,
+        uiStatus: services.uiStatus,
+        ready: startHydration(() => closing),
+        close,
+    };
+}
+export function installSignalHandlers(starting, exit = (code) => process.exit(code)) {
+    let stopping = false;
+    function stop() {
+        if (stopping)
+            return;
+        stopping = true;
+        setTimeout(() => exit(1), SHUTDOWN_WATCHDOG_MS).unref();
+        starting
+            .then((running) => running.close())
+            .then(() => exit(0), () => exit(1));
+    }
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+}

package/dist/server-lock.js

@@ -0,0 +1,143 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export const SERVER_LOCK_FILENAME = ".videobook-server.json";
+const HEALTH_TIMEOUT_MS = 1_500;
+export class ServerAlreadyRunningError extends Error {
+    running;
+    libraryDir;
+    constructor(running, libraryDir, responding) {
+        super(responding
+            ? `videobook is already running at ${running.url} (pid ${running.pid}) for library ${libraryDir}. Open that URL or stop it first.`
+            : `videobook (pid ${running.pid}) holds library ${libraryDir} at ${running.url} but is not responding. Stop that process first.`);
+        this.name = "ServerAlreadyRunningError";
+        this.running = running;
+        this.libraryDir = libraryDir;
+    }
+}
+export function serverLockPath(libraryDir) {
+    return join(libraryDir, SERVER_LOCK_FILENAME);
+}
+export function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function errorCode(error) {
+    return error?.code;
+}
+function parseServerLock(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value.pid !== "number" || typeof value.port !== "number" || typeof value.url !== "string")
+            return null;
+        return {
+            pid: value.pid,
+            port: value.port,
+            url: value.url,
+            startedAt: typeof value.startedAt === "string" ? value.startedAt : "",
+            version: typeof value.version === "string" ? value.version : "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function readServerLock(libraryDir) {
+    try {
+        return parseServerLock(await readFile(serverLockPath(libraryDir), "utf8"));
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function healthFailure(error) {
+    if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError"))
+        return "timeout";
+    return "refused";
+}
+async function askHealth(url, timeoutMs) {
+    try {
+        const response = await fetch(new URL("/healthz", url), { signal: AbortSignal.timeout(timeoutMs) });
+        if (!response.ok)
+            return "other";
+        const body = await response.json();
+        return body.ok === true && body.service === "videobook" ? "videobook" : "other";
+    }
+    catch (error) {
+        return healthFailure(error);
+    }
+}
+export async function inspectServerOwner(libraryDir, timeoutMs = HEALTH_TIMEOUT_MS) {
+    const record = await readServerLock(libraryDir);
+    if (!record || !processAlive(record.pid))
+        return { kind: "none" };
+    const answer = await askHealth(record.url, timeoutMs);
+    if (answer === "videobook")
+        return { kind: "running", record };
+    if (answer === "timeout")
+        return { kind: "unresponsive", record };
+    return { kind: "none" };
+}
+function sameRecord(left, right) {
+    return left !== null && left.pid === right.pid && left.startedAt === right.startedAt;
+}
+async function writeExclusive(path, record) {
+    const staging = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(staging, `${JSON.stringify(record)}\n`, { encoding: "utf8", flag: "wx" });
+    try {
+        await link(staging, path);
+        return true;
+    }
+    catch (error) {
+        if (errorCode(error) === "EEXIST")
+            return false;
+        throw error;
+    }
+    finally {
+        await unlink(staging).catch(() => undefined);
+    }
+}
+async function removeIfUnchanged(libraryDir, expected) {
+    const current = await readServerLock(libraryDir);
+    if (expected === null ? current !== null : !sameRecord(current, expected))
+        return;
+    await unlink(serverLockPath(libraryDir)).catch((error) => {
+        if (errorCode(error) !== "ENOENT")
+            throw error;
+    });
+}
+function lockHandle(libraryDir, record) {
+    let released = false;
+    return {
+        path: serverLockPath(libraryDir),
+        record,
+        async release() {
+            if (released)
+                return;
+            released = true;
+            await removeIfUnchanged(libraryDir, record);
+        },
+    };
+}
+export async function acquireServerLock(libraryDir, fields) {
+    await mkdir(libraryDir, { recursive: true });
+    const record = { ...fields, startedAt: new Date().toISOString() };
+    const path = serverLockPath(libraryDir);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        if (await writeExclusive(path, record))
+            return lockHandle(libraryDir, record);
+        const stale = await readServerLock(libraryDir);
+        const owner = await inspectServerOwner(libraryDir);
+        if (owner.kind !== "none")
+            throw new ServerAlreadyRunningError(owner.record, libraryDir, owner.kind === "running");
+        await removeIfUnchanged(libraryDir, stale);
+    }
+    throw new Error(`Could not acquire the videobook server lock at ${path}`);
+}

package/dist/server.js

@@ -0,0 +1,42 @@
+import { createMcpHandler, McpServer, } from "@modelcontextprotocol/server";
+import { createRequire } from "node:module";
+import { registerAllTools } from "./tools/index.js";
+import { bookManager, scopedEngine as defaultFs } from "./engine.js";
+import { allowsHttpRequest } from "./http-access.js";
+export const MCP_PROTOCOL_VERSION = "2026-07-28";
+export const SERVER_VERSION = createRequire(import.meta.url)("../package.json").version;
+export function serverInstructions(baseUrl) {
+    return [
+        "Videobook is a local-first notebook for AI video creation.",
+        `Tools return media as paths such as /files/<bookId>/<artifactId>/<name>; fetch them from ${baseUrl}.`,
+        `The web UI for this library is at ${baseUrl}/.`,
+        "Generation and rendering run as queued jobs; follow them with list_jobs or wait_for_asset_ready.",
+    ].join(" ");
+}
+export function createServer(engine = defaultFs, books = bookManager, options = {}) {
+    const server = new McpServer({
+        name: "videobook",
+        version: SERVER_VERSION,
+    }, {
+        supportedProtocolVersions: [MCP_PROTOCOL_VERSION],
+        ...(options.instructions ? { instructions: options.instructions } : {}),
+    });
+    registerAllTools(server, engine, books);
+    return server;
+}
+export function createHttpHandler(engine = defaultFs, books = bookManager) {
+    const resolveEngine = typeof engine === "function" ? engine : () => engine;
+    const handler = createMcpHandler(() => createServer(resolveEngine(), books), {
+        legacy: "reject",
+    });
+    return {
+        ...handler,
+        async fetch(request, options) {
+            const urlHost = new URL(request.url).host;
+            if (!allowsHttpRequest(urlHost, null, null) || !allowsHttpRequest(request.headers.get("host") ?? urlHost, request.headers.get("origin"), request.headers.get("sec-fetch-site"))) {
+                return Response.json({ error: "HTTP request origin or host is not allowed" }, { status: 403 });
+            }
+            return handler.fetch(request, options);
+        },
+    };
+}