videobook 0.0.0-stage → 0.1.0

package/dist/chat-view-actions.js

@@ -0,0 +1,49 @@
+import { resolveNotebookCellArtifactId } from "videobook-engine";
+import { notebookGridTag } from "videobook-engine/notebook-grid";
+import { z } from "zod";
+import { resolveNotebookArtifactReference } from "./notebook-reference-resolver.js";
+const SHOW_MEDIA_FULLSCREEN = "show_media_fullscreen";
+const FULLSCREEN_MEDIA_KINDS = ["image", "video", "final"];
+const CHAT_VIEW_ACTIONS = [
+    {
+        name: SHOW_MEDIA_FULLSCREEN,
+        description: "Show, open, view or enlarge one notebook cell's image or video in the fullscreen viewer. Changes nothing in the book",
+        schema: {
+            asset_id: z.string().min(1).describe("Artifact ID or grid address of the cell's image or video"),
+        },
+    },
+];
+function resolveMediaFullscreen(engine, notebook, reference) {
+    if (!notebook)
+        return { ok: false, message: "Open a notebook before showing media fullscreen" };
+    const resolved = resolveNotebookArtifactReference({ engine, documents: [notebook], reference });
+    if ("code" in resolved)
+        return { ok: false, message: resolved.message };
+    const cell = notebook.cells.find((candidate) => resolved.cellId
+        ? candidate.id === resolved.cellId
+        : resolveNotebookCellArtifactId(notebook, candidate) === resolved.artifactId);
+    if (!cell)
+        return { ok: false, message: `No cell in this notebook holds ${resolved.mention}` };
+    const artifact = engine.artifacts.get(resolved.artifactId);
+    if (!artifact.ok)
+        return { ok: false, message: artifact.error.message };
+    if (!FULLSCREEN_MEDIA_KINDS.includes(artifact.value.kind)) {
+        return {
+            ok: false,
+            message: `${notebookGridTag(cell.slot)} holds ${artifact.value.kind}; fullscreen shows images and video`,
+        };
+    }
+    return { ok: true, params: { asset_id: resolved.artifactId, cell_id: cell.id } };
+}
+/** Validate a routed view action and pin it to the cell the app should open. */
+function resolveChatViewAction(engine, notebook, tool, params) {
+    const action = CHAT_VIEW_ACTIONS.find((candidate) => candidate.name === tool);
+    if (!action)
+        return { ok: false, message: `Unknown view action: ${tool}` };
+    const parsed = z.object(action.schema).safeParse(params);
+    if (!parsed.success) {
+        return { ok: false, message: `Invalid parameters for ${tool}: ${z.prettifyError(parsed.error)}` };
+    }
+    return resolveMediaFullscreen(engine, notebook, String(parsed.data.asset_id));
+}
+export { CHAT_VIEW_ACTIONS, resolveChatViewAction };

package/dist/cli/args.js

@@ -0,0 +1,192 @@
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+export class CliUsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CliUsageError";
+    }
+}
+const LOG_LEVELS = new Set(["silent", "error", "warn", "info", "debug"]);
+const COMMANDS = new Set(["serve", "mcp", "run", "tools", "gc-books", "doctor", "version", "help"]);
+const DEFAULT_RUN_TIMEOUT_SECONDS = 600;
+const GLOBAL_OPTIONS = {
+    port: { type: "string" },
+    library: { type: "string" },
+    home: { type: "string" },
+    "log-level": { type: "string" },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" },
+};
+const COMMAND_OPTIONS = {
+    serve: { headless: { type: "boolean" }, "no-ui": { type: "boolean" }, open: { type: "boolean" } },
+    mcp: {},
+    run: { wait: { type: "boolean" }, "no-wait": { type: "boolean" }, timeout: { type: "string" } },
+    tools: {},
+    "gc-books": {},
+    doctor: { json: { type: "boolean" } },
+};
+function splitCommand(argv) {
+    const [first, ...rest] = argv;
+    if (first === undefined || first.startsWith("-"))
+        return { command: "serve", rest: argv };
+    if (!COMMANDS.has(first))
+        throw new CliUsageError(`Unknown command "${first}".`);
+    return { command: first, rest };
+}
+function parsePort(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    const port = Number(raw);
+    if (!/^\d+$/u.test(raw) || port > 65535)
+        throw new CliUsageError(`--port must be an integer from 0 to 65535, got "${raw}".`);
+    return port;
+}
+function parseLogLevel(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    if (!LOG_LEVELS.has(raw))
+        throw new CliUsageError(`--log-level must be one of silent, error, warn, info, debug; got "${raw}".`);
+    return raw;
+}
+function parseTimeout(raw) {
+    if (typeof raw !== "string")
+        return DEFAULT_RUN_TIMEOUT_SECONDS;
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0)
+        throw new CliUsageError(`--timeout must be a positive number of seconds, got "${raw}".`);
+    return seconds;
+}
+function stringValue(raw) {
+    return typeof raw === "string" && raw.trim() !== "" ? raw : undefined;
+}
+function globalFlags(values) {
+    const flags = {};
+    const port = parsePort(values.port);
+    const library = stringValue(values.library);
+    const home = stringValue(values.home);
+    const logLevel = parseLogLevel(values["log-level"]);
+    if (port !== undefined)
+        flags.port = port;
+    if (library !== undefined)
+        flags.library = library;
+    if (home !== undefined)
+        flags.home = home;
+    if (logLevel !== undefined)
+        flags.logLevel = logLevel;
+    return flags;
+}
+function parseValue(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export function parseToolArgs(pairs) {
+    const args = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf("=");
+        if (eq <= 0)
+            throw new CliUsageError(`Invalid tool argument "${pair}". Use key=value.`);
+        args[pair.slice(0, eq)] = parseValue(pair.slice(eq + 1));
+    }
+    return args;
+}
+function parseCommandArgs(command, rest) {
+    try {
+        const parsed = parseArgs({
+            args: rest,
+            options: { ...GLOBAL_OPTIONS, ...COMMAND_OPTIONS[command] },
+            allowPositionals: command === "run",
+            strict: true,
+        });
+        return { values: parsed.values, positionals: parsed.positionals };
+    }
+    catch (error) {
+        throw new CliUsageError(error instanceof Error ? error.message : String(error));
+    }
+}
+function buildCommand(command, values, positionals) {
+    const flags = globalFlags(values);
+    switch (command) {
+        case "serve":
+            return { command, flags: { ...flags, ui: values.headless !== true && values["no-ui"] !== true, open: values.open === true } };
+        case "run": {
+            const [tool, ...pairs] = positionals;
+            if (!tool)
+                throw new CliUsageError("run needs a tool name, for example: videobook run list_books");
+            return { command, tool, toolArgs: parseToolArgs(pairs), flags: { ...flags, wait: values["no-wait"] !== true, timeoutSeconds: parseTimeout(values.timeout) } };
+        }
+        case "doctor":
+            return { command, flags: { ...flags, json: values.json === true } };
+        default:
+            return { command, flags };
+    }
+}
+export function parseCli(argv) {
+    const { command, rest } = splitCommand(argv);
+    if (command === "help")
+        return { command: "help" };
+    if (command === "version")
+        return { command: "version" };
+    const name = command;
+    const { values, positionals } = parseCommandArgs(name, rest);
+    if (values.help === true)
+        return { command: "help" };
+    if (values.version === true)
+        return { command: "version" };
+    return buildCommand(name, values, positionals);
+}
+const HOME_DERIVED_ENV = ["VIDEOBOOK_LIBRARY_DIR", "VIDEOBOOK_APP_STATE_PATH", "VIDEOBOOK_ENV_PATH"];
+function applyHome(home, env, cwd) {
+    env.VIDEOBOOK_HOME = resolve(cwd, home);
+    for (const name of HOME_DERIVED_ENV)
+        delete env[name];
+}
+export function applyFlagsToEnv(flags, env, cwd) {
+    if (flags.home !== undefined)
+        applyHome(flags.home, env, cwd);
+    if (flags.library !== undefined)
+        env.VIDEOBOOK_LIBRARY_DIR = resolve(cwd, flags.library);
+    if (flags.port !== undefined)
+        env.PORT = String(flags.port);
+    if (flags.logLevel !== undefined)
+        env.VIDEOBOOK_LOG_LEVEL = flags.logLevel;
+}
+export function resolvePort(env) {
+    const raw = env.PORT?.trim();
+    const port = raw ? Number(raw) : 3001;
+    return Number.isInteger(port) && port >= 0 && port <= 65535 ? port : 3001;
+}
+export function helpText() {
+    return [
+        "Usage: videobook [command] [options]",
+        "",
+        "Commands:",
+        "  serve              Run the MCP server with the web UI (default)",
+        "  mcp                Serve MCP over stdio for agent hosts such as Claude Code",
+        "  run <tool> [k=v]   Call one MCP tool and print its result",
+        "  tools              List the MCP tools and their parameters",
+        "  gc-books           Reclaim catalog storage in every book",
+        "  doctor             Check Node, media binaries, native modules and keys",
+        "  version            Print versions",
+        "  help               Print this help",
+        "",
+        "Options:",
+        "  --port <n>         HTTP port on 127.0.0.1 (default 3001, or PORT)",
+        "  --library <dir>    Book library directory (default <data home>/books)",
+        "  --home <dir>       Data home (default ~/.videobook, or VIDEOBOOK_HOME)",
+        "  --log-level <l>    silent, error, warn, info or debug",
+        "  --headless         serve: MCP and API only, no web UI (alias --no-ui)",
+        "  --open             serve: open the web UI in a browser",
+        "  --no-wait          run: do not wait for queued jobs",
+        "  --timeout <s>      run: seconds to wait for jobs (default 600)",
+        "  --json             doctor: print machine-readable results",
+        "  -v, --version      Print versions",
+        "  -h, --help         Print this help",
+        "",
+        "Agent hosts:  claude mcp add videobook -- videobook mcp",
+        "",
+    ].join("\n");
+}

package/dist/cli/doctor-command.js

@@ -0,0 +1,255 @@
+import { execFile } from "node:child_process";
+import { access, constants, readdir } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { SCHEMA_VERSION } from "videobook-engine/catalog-metadata";
+import { resolvePort } from "./args.js";
+import { dataLayout } from "../data-home.js";
+import { bookManager } from "../engine.js";
+import { MANAGED_ENV_KEYS, getDefaultSecretStore, isSecretEnvKey, maskEnvValue } from "../env-secrets.js";
+import { FFMPEG } from "../ffmpeg-binary.js";
+import { FFPROBE } from "../ffprobe-binary.js";
+import { inspectServerOwner } from "../server-lock.js";
+import { remotionBrowserDir, remotionCacheRoot } from "../remotion/browser.js";
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+const UUID_V7 = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+const ALLOW_SCRIPTS = "ffmpeg-static,ytdlp-nodejs,@dolthub/doltlite,usearch,onnxruntime-node,esbuild";
+const INSTALL_REMEDY = `Reinstall with install scripts allowed: npm install -g videobook --allow-scripts=${ALLOW_SCRIPTS}`;
+function check(fields) {
+    return fields;
+}
+function message(error) {
+    return error instanceof Error ? error.message.split("\n")[0] ?? error.message : String(error);
+}
+function nodeCheck() {
+    const engines = require("../../package.json").engines?.node ?? ">=22";
+    const minimum = Number(/(\d+)/u.exec(engines)?.[1] ?? 22);
+    const major = Number(process.versions.node.split(".")[0]);
+    return check({
+        id: "node",
+        label: "Node.js",
+        status: major >= minimum ? "ok" : "fail",
+        detail: `${process.version} (needs ${engines})`,
+        ...(major >= minimum ? {} : { remedy: `Install Node.js ${minimum} or newer.` }),
+        required: true,
+    });
+}
+async function nearestExisting(path) {
+    let current = path;
+    for (;;) {
+        try {
+            await access(current);
+            return current;
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return current;
+            current = parent;
+        }
+    }
+}
+async function dataHomeCheck() {
+    const layout = dataLayout();
+    const kind = layout.kind === "checkout" ? "source checkout" : process.env.VIDEOBOOK_HOME?.trim() ? "VIDEOBOOK_HOME" : "default";
+    const target = await nearestExisting(layout.root);
+    try {
+        await access(target, constants.W_OK);
+        return check({ id: "data-home", label: "Data home", status: "ok", detail: `${layout.root} (${kind}); .env ${layout.envPath}`, required: true });
+    }
+    catch {
+        return check({
+            id: "data-home",
+            label: "Data home",
+            status: "fail",
+            detail: `${layout.root} is not writable (${kind})`,
+            remedy: "Set VIDEOBOOK_HOME or pass --home to a writable directory.",
+            required: true,
+        });
+    }
+}
+async function libraryCheck() {
+    const libraryDir = bookManager.rootDir;
+    try {
+        const books = (await readdir(libraryDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && UUID_V7.test(entry.name));
+        return check({ id: "library", label: "Library", status: "ok", detail: `${libraryDir}: ${books.length} book(s), schema ${SCHEMA_VERSION}`, required: false });
+    }
+    catch {
+        return check({ id: "library", label: "Library", status: "ok", detail: `${libraryDir} is created on first start (schema ${SCHEMA_VERSION})`, required: false });
+    }
+}
+function bundledPath(moduleName) {
+    try {
+        const value = require(moduleName);
+        return typeof value === "string" ? value : value?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function binaryCheck(id, label, binary, bundled, envName) {
+    const origin = binary === bundled ? "bundled" : binary.includes("/") ? envName : "from PATH";
+    try {
+        const { stdout } = await execFileAsync(binary, ["-version"], { timeout: 15_000 });
+        return check({ id, label, status: "ok", detail: `${stdout.split("\n")[0]} (${origin}: ${binary})`, required: true });
+    }
+    catch (error) {
+        return check({
+            id,
+            label,
+            status: "fail",
+            detail: `${binary} did not run: ${message(error)}`,
+            remedy: `${INSTALL_REMEDY}, install ${label} on PATH, or set ${envName}.`,
+            required: true,
+        });
+    }
+}
+function ytdlpCheck() {
+    try {
+        const { helpers } = require("ytdlp-nodejs");
+        const binary = helpers.findYtdlpBinary();
+        if (binary)
+            return check({ id: "yt-dlp", label: "yt-dlp", status: "ok", detail: binary, required: false });
+    }
+    catch (error) {
+        return check({ id: "yt-dlp", label: "yt-dlp", status: "warn", detail: message(error), remedy: INSTALL_REMEDY, required: false });
+    }
+    return check({
+        id: "yt-dlp",
+        label: "yt-dlp",
+        status: "warn",
+        detail: "not downloaded; download_video and archive_clip from URLs will fail",
+        remedy: INSTALL_REMEDY,
+        required: false,
+    });
+}
+function sharedObjects(pattern) {
+    const report = process.report.getReport();
+    return (report.sharedObjects ?? []).filter((name) => pattern.test(name));
+}
+function engineRequire() {
+    return createRequire(require.resolve("videobook-engine/package.json"));
+}
+function nativeCoreCheck() {
+    try {
+        const { DatabaseSync } = engineRequire()("@dolthub/doltlite");
+        const database = new DatabaseSync(":memory:");
+        const dolt = database.doltVersion();
+        database.close();
+        const sharp = require("sharp");
+        const copies = sharedObjects(/sharp[^/\\]*\.node$/u).length;
+        return check({
+            id: "native-runtime",
+            label: "Native modules",
+            status: copies > 1 ? "fail" : "ok",
+            detail: `DoltLite ${dolt}; Sharp ${sharp.versions.sharp ?? "?"} / libvips ${sharp.versions.vips ?? "?"}${copies > 1 ? `; ${copies} Sharp copies loaded` : ""}`,
+            ...(copies > 1 ? { remedy: "Reinstall videobook so npm dedupes Sharp to one copy." } : {}),
+            required: true,
+        });
+    }
+    catch (error) {
+        return check({ id: "native-runtime", label: "Native modules", status: "fail", detail: message(error), remedy: INSTALL_REMEDY, required: true });
+    }
+}
+function searchRuntimeCheck() {
+    const fromEngine = engineRequire();
+    try {
+        fromEngine("onnxruntime-node");
+        fromEngine("usearch");
+        return check({ id: "search-runtime", label: "Semantic search", status: "ok", detail: "ONNX Runtime and USearch load", required: false });
+    }
+    catch (error) {
+        return check({
+            id: "search-runtime",
+            label: "Semantic search",
+            status: "warn",
+            detail: `unavailable on ${process.platform}-${process.arch}: ${message(error)}`,
+            required: false,
+        });
+    }
+}
+async function renderBrowserCheck() {
+    const root = remotionCacheRoot();
+    if (!root) {
+        return check({ id: "render-browser", label: "Render browser", status: "ok", detail: "managed by Remotion in this source checkout", required: false });
+    }
+    const directory = remotionBrowserDir(root);
+    try {
+        await access(join(directory, "chrome-headless-shell"));
+        return check({ id: "render-browser", label: "Render browser", status: "ok", detail: `Chrome Headless Shell in ${directory}`, required: false });
+    }
+    catch {
+        return check({
+            id: "render-browser",
+            label: "Render browser",
+            status: "warn",
+            detail: `not downloaded yet; the first render downloads Chrome Headless Shell into ${directory}`,
+            required: false,
+        });
+    }
+}
+function providerKeysCheck() {
+    const store = getDefaultSecretStore();
+    const configured = MANAGED_ENV_KEYS.filter((key) => key.endsWith("_API_KEY") && store.getSource(key) !== "missing");
+    if (configured.length === 0) {
+        return check({
+            id: "provider-keys",
+            label: "Provider keys",
+            status: "warn",
+            detail: "none configured; generation and transcription tools will fail",
+            remedy: `Add keys such as OPENAI_API_KEY to ${dataLayout().envPath} or the environment.`,
+            required: false,
+        });
+    }
+    const shown = configured.map((key) => {
+        const value = store.getValue(key) ?? "";
+        return `${key}=${isSecretEnvKey(key) ? maskEnvValue(value) : value} (${store.getSource(key)})`;
+    });
+    return check({ id: "provider-keys", label: "Provider keys", status: "ok", detail: shown.join(", "), required: false });
+}
+async function ownerCheck(port) {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    if (owner.kind === "running") {
+        return check({ id: "owner", label: "Server", status: "ok", detail: `running at ${owner.record.url} (pid ${owner.record.pid})`, required: false });
+    }
+    if (owner.kind === "unresponsive") {
+        return check({ id: "owner", label: "Server", status: "warn", detail: `pid ${owner.record.pid} holds the library but does not answer at ${owner.record.url}`, required: false });
+    }
+    return check({ id: "owner", label: "Server", status: "ok", detail: `not running (videobook serve listens on 127.0.0.1:${port})`, required: false });
+}
+async function collectDoctorChecks() {
+    return [
+        nodeCheck(),
+        await dataHomeCheck(),
+        await libraryCheck(),
+        await binaryCheck("ffmpeg", "ffmpeg", FFMPEG, bundledPath("ffmpeg-static"), "VIDEOBOOK_FFMPEG_PATH"),
+        await binaryCheck("ffprobe", "ffprobe", FFPROBE, bundledPath("ffprobe-static"), "VIDEOBOOK_FFPROBE_PATH"),
+        ytdlpCheck(),
+        nativeCoreCheck(),
+        searchRuntimeCheck(),
+        await renderBrowserCheck(),
+        providerKeysCheck(),
+        await ownerCheck(resolvePort(process.env)),
+    ];
+}
+function statusLabel(status) {
+    return status === "ok" ? "ok  " : status === "warn" ? "warn" : "FAIL";
+}
+function renderText(checks) {
+    const lines = checks.flatMap((item) => [
+        `${statusLabel(item.status)}  ${item.label.padEnd(16)} ${item.detail}`,
+        ...(item.remedy && item.status !== "ok" ? [`      ${"".padEnd(16)} fix: ${item.remedy}`] : []),
+    ]);
+    return `${lines.join("\n")}\n`;
+}
+function doctorExitCode(checks) {
+    return checks.some((item) => item.required && item.status === "fail") ? 1 : 0;
+}
+export async function runDoctorCommand(flags) {
+    const checks = await collectDoctorChecks();
+    const code = doctorExitCode(checks);
+    process.stdout.write(flags.json ? `${JSON.stringify({ ok: code === 0, checks }, null, 2)}\n` : renderText(checks));
+    return code;
+}

package/dist/cli/entry.js

@@ -0,0 +1,2 @@
+import { runCli } from "./main.js";
+await runCli(process.argv.slice(2));

package/dist/cli/main.js

@@ -0,0 +1,91 @@
+import { createRequire } from "node:module";
+import { SCHEMA_VERSION } from "videobook-engine/catalog-metadata";
+import { redirectConsoleToStderr } from "./stdio-guard.js";
+import { CliUsageError, applyFlagsToEnv, helpText, parseCli, } from "./args.js";
+const MCP_PROTOCOL_VERSION = "2026-07-28";
+function versionLine() {
+    const require = createRequire(import.meta.url);
+    const own = require("../../package.json");
+    const engine = require("videobook-engine/package.json");
+    return `videobook ${own.version} (engine ${engine.version}, schema ${SCHEMA_VERSION}, mcp ${MCP_PROTOCOL_VERSION})`;
+}
+function parseOrReport(argv) {
+    try {
+        return parseCli(argv);
+    }
+    catch (error) {
+        if (!(error instanceof CliUsageError))
+            throw error;
+        process.stderr.write(`${error.message}\n\n${helpText()}`);
+        return 2;
+    }
+}
+async function runCommand(parsed) {
+    switch (parsed.command) {
+        case "serve": {
+            const { runServeCommand } = await import("./serve-command.js");
+            return runServeCommand(parsed.flags);
+        }
+        case "mcp": {
+            const { runMcpCommand } = await import("./mcp-command.js");
+            return runMcpCommand();
+        }
+        case "run": {
+            const { runToolCommand } = await import("./run-command.js");
+            return runToolCommand(parsed.flags, parsed.tool, parsed.toolArgs);
+        }
+        case "tools": {
+            const { runToolsCommand } = await import("./run-command.js");
+            return runToolsCommand();
+        }
+        case "gc-books": {
+            const { runGcBooksCommand } = await import("./run-command.js");
+            return runGcBooksCommand();
+        }
+        case "doctor": {
+            const { runDoctorCommand } = await import("./doctor-command.js");
+            return runDoctorCommand(parsed.flags);
+        }
+    }
+}
+async function main(argv) {
+    const parsed = parseOrReport(argv);
+    if (typeof parsed === "number")
+        return parsed;
+    if (parsed.command === "help") {
+        process.stdout.write(helpText());
+        return 0;
+    }
+    if (parsed.command === "version") {
+        process.stdout.write(`${versionLine()}\n`);
+        return 0;
+    }
+    applyFlagsToEnv(parsed.flags, process.env, process.cwd());
+    if (parsed.command !== "serve")
+        redirectConsoleToStderr();
+    await import("../load-env.js");
+    return runCommand(parsed);
+}
+function flushed(stream) {
+    return new Promise((resolveFlush) => stream.write("", () => resolveFlush()));
+}
+function exitOnBrokenPipe(stream) {
+    stream.on("error", (error) => {
+        if (error.code !== "EPIPE")
+            throw error;
+        process.exit(0);
+    });
+}
+export async function runCli(argv) {
+    exitOnBrokenPipe(process.stdout);
+    let code;
+    try {
+        code = await main(argv);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+        code = 1;
+    }
+    await Promise.all([flushed(process.stdout), flushed(process.stderr)]);
+    process.exit(code);
+}

package/dist/cli/mcp-command.js

@@ -0,0 +1,82 @@
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { resolvePort } from "./args.js";
+import { connectUpstream, createRelayServer } from "./mcp-relay.js";
+import { bookManager, scopedEngine } from "../engine.js";
+import { logger } from "../logger.js";
+import { createServer, serverInstructions } from "../server.js";
+import { ServerAlreadyRunningError, inspectServerOwner } from "../server-lock.js";
+import { startServer } from "../serve.js";
+function stdinEnded() {
+    return new Promise((resolveEnd) => {
+        process.stdin.once("end", () => resolveEnd(0));
+        process.stdin.once("close", () => resolveEnd(0));
+    });
+}
+function signalled() {
+    return new Promise((resolveSignal) => {
+        process.once("SIGINT", () => resolveSignal(0));
+        process.once("SIGTERM", () => resolveSignal(0));
+    });
+}
+function reportStdioError(error) {
+    process.stderr.write(`videobook mcp: ${error.message}\n`);
+}
+function hydrationFailure(running) {
+    return running.ready.then(() => new Promise(() => undefined), (error) => {
+        logger.error("startup-failed", { error, port: running.port });
+        return 1;
+    });
+}
+async function relayTo(owner) {
+    const upstream = await connectUpstream(`${owner.url}/mcp`);
+    const handle = serveStdio(() => createRelayServer(upstream, serverInstructions(owner.url)), { onerror: reportStdioError });
+    process.stderr.write(`videobook mcp: relaying stdio to ${owner.url}/mcp (pid ${owner.pid})\n`);
+    const code = await Promise.race([stdinEnded(), signalled()]);
+    await handle.close();
+    await upstream.close();
+    return code;
+}
+async function startOwner(port) {
+    try {
+        return await startServer({ port, ui: true });
+    }
+    catch (error) {
+        if (error?.code !== "EADDRINUSE" || port === 0)
+            throw error;
+        process.stderr.write(`videobook mcp: port ${port} is busy; using a free port.\n`);
+        return await startServer({ port: 0, ui: true });
+    }
+}
+async function serveInProcess(running) {
+    const instructions = serverInstructions(running.url);
+    const handle = serveStdio(() => createServer(scopedEngine, bookManager, { instructions }), { onerror: reportStdioError });
+    process.stderr.write(`videobook mcp: serving stdio; web UI and HTTP MCP at ${running.url}/ for library ${running.libraryDir}\n`);
+    const code = await Promise.race([stdinEnded(), signalled(), hydrationFailure(running)]);
+    await handle.close();
+    await running.close();
+    return code;
+}
+async function ownOrRelay(port) {
+    let running;
+    try {
+        running = await startOwner(port);
+    }
+    catch (error) {
+        if (error instanceof ServerAlreadyRunningError && error.running.url)
+            return relayTo(error.running);
+        logger.error("startup-failed", { error, port });
+        process.stderr.write(`videobook mcp: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    return serveInProcess(running);
+}
+export async function runMcpCommand() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    if (owner.kind === "running")
+        return relayTo(owner.record);
+    if (owner.kind === "unresponsive") {
+        process.stderr.write(`videobook mcp: videobook (pid ${owner.record.pid}) holds ${bookManager.rootDir} but is not responding. Stop it first.\n`);
+        return 1;
+    }
+    return ownOrRelay(resolvePort(process.env));
+}