videobook 0.0.0-stage → 0.2.0

package/dist/cli/entry.js

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

package/dist/cli/key-report.js

@@ -0,0 +1,16 @@
+import { getDefaultSecretStore } from "../env-secrets.js";
+export function onePasswordSummary() {
+    const resolution = getDefaultSecretStore().onePasswordResolution();
+    if (!resolution?.attempted)
+        return null;
+    const filled = resolution.fromReferences.length + resolution.fromVault.length;
+    const vault = resolution.vault ? ` (vault ${resolution.vault})` : "";
+    return `${filled} key(s) from 1Password${vault}`;
+}
+export function onePasswordWarnings() {
+    const resolution = getDefaultSecretStore().onePasswordResolution();
+    if (!resolution?.attempted)
+        return [];
+    const failures = resolution.unresolved.map((item) => `could not resolve ${item.key} from ${item.reference}: ${item.reason}`);
+    return resolution.error ? [resolution.error, ...failures] : failures;
+}

package/dist/cli/main.js

@@ -0,0 +1,104 @@
+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);
+        }
+        case "setup": {
+            const { runSetupCommand } = await import("./setup-command.js");
+            return runSetupCommand(parsed.flags);
+        }
+        case "config": {
+            const { runConfigCommand } = await import("./config-command.js");
+            return runConfigCommand(parsed);
+        }
+    }
+}
+async function loadDotenv() {
+    const { getDefaultSecretStore } = await import("../env-secrets.js");
+    getDefaultSecretStore().loadDotenv();
+}
+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();
+    if (parsed.command !== "setup" && parsed.command !== "config")
+        await loadDotenv();
+    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,88 @@
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { resolvePort } from "./args.js";
+import { onePasswordSummary, onePasswordWarnings } from "./key-report.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 keys = onePasswordSummary();
+    if (keys)
+        process.stderr.write(`videobook mcp: ${keys}\n`);
+    for (const warning of onePasswordWarnings())
+        process.stderr.write(`videobook mcp: ${warning}\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));
+}

package/dist/cli/mcp-relay.js

@@ -0,0 +1,51 @@
+import { Client, ProtocolError, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { McpServer, fromJsonSchema, } from "@modelcontextprotocol/server";
+import { MCP_PROTOCOL_VERSION, SERVER_VERSION } from "../server.js";
+const RELAYED_CALL_TIMEOUT_MS = 30 * 60_000;
+async function listAllTools(client) {
+    const tools = [];
+    let cursor;
+    do {
+        const page = await client.listTools(cursor === undefined ? undefined : { cursor });
+        tools.push(...page.tools);
+        cursor = page.nextCursor;
+    } while (cursor !== undefined);
+    return tools;
+}
+export async function connectUpstream(mcpUrl) {
+    const client = new Client({ name: "videobook-mcp-relay", version: SERVER_VERSION }, {
+        capabilities: {},
+        supportedProtocolVersions: [MCP_PROTOCOL_VERSION],
+        versionNegotiation: { mode: { pin: MCP_PROTOCOL_VERSION } },
+    });
+    await client.connect(new StreamableHTTPClientTransport(new URL(mcpUrl)));
+    return { url: mcpUrl, client, tools: await listAllTools(client), close: () => client.close() };
+}
+function relayFailure(url, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const text = error instanceof ProtocolError
+        ? reason
+        : `The videobook server at ${url} did not answer (${reason}). Restart it or restart videobook mcp.`;
+    return { isError: true, content: [{ type: "text", text }] };
+}
+function registerRelayedTool(server, upstream, tool) {
+    server.registerTool(tool.name, {
+        ...(tool.title ? { title: tool.title } : {}),
+        ...(tool.description ? { description: tool.description } : {}),
+        ...(tool.annotations ? { annotations: tool.annotations } : {}),
+        inputSchema: fromJsonSchema(tool.inputSchema),
+    }, async (args, ctx) => {
+        try {
+            return await upstream.client.callTool({ name: tool.name, arguments: args }, { timeout: RELAYED_CALL_TIMEOUT_MS, signal: ctx.mcpReq.signal });
+        }
+        catch (error) {
+            return relayFailure(upstream.url, error);
+        }
+    });
+}
+export function createRelayServer(upstream, instructions) {
+    const server = new McpServer({ name: "videobook", version: SERVER_VERSION }, { instructions });
+    for (const tool of upstream.tools)
+        registerRelayedTool(server, upstream, tool);
+    return server;
+}

package/dist/cli/open-browser.js

@@ -0,0 +1,14 @@
+import { spawn } from "node:child_process";
+function browserCommand(url, platform) {
+    if (platform === "darwin")
+        return { command: "open", args: [url] };
+    if (platform === "win32")
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    return { command: "xdg-open", args: [url] };
+}
+export function openInBrowser(url, platform = process.platform) {
+    const { command, args } = browserCommand(url, platform);
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => undefined);
+    child.unref();
+}

package/dist/cli/run-command.js

@@ -0,0 +1,231 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { z } from "zod";
+import { onePasswordWarnings } from "./key-report.js";
+import { gcLibraryCatalogs } from "../catalog-gc.js";
+import { bookManager, scopedEngine } from "../engine.js";
+import { MCP_PROTOCOL_VERSION, SERVER_VERSION } from "../server.js";
+import { inspectServerOwner } from "../server-lock.js";
+import { startServer } from "../serve.js";
+import { getAllToolDefs } from "../tools/index.js";
+const REQUEST_GRACE_MS = 60_000;
+const JOB_POLL_MS = 1_000;
+const FINISHED_JOB_STATES = new Set(["done", "failed", "aborted"]);
+const SETTLED_STATUSES = new Set(["completed", "done"]);
+function newClient() {
+    return new Client({ name: "videobook-cli", version: SERVER_VERSION }, {
+        capabilities: {},
+        supportedProtocolVersions: [MCP_PROTOCOL_VERSION],
+        versionNegotiation: { mode: { pin: MCP_PROTOCOL_VERSION } },
+    });
+}
+async function connect(mcpUrl) {
+    const client = newClient();
+    await client.connect(new StreamableHTTPClientTransport(new URL(mcpUrl)));
+    return client;
+}
+function refuseUnresponsive(owner) {
+    if (owner.kind !== "unresponsive")
+        return;
+    throw new Error(`videobook (pid ${owner.record.pid}) holds ${bookManager.rootDir} but is not responding. Stop it first.`);
+}
+async function temporaryOwner() {
+    const running = await startServer({ port: 0, ui: false });
+    for (const warning of onePasswordWarnings())
+        process.stderr.write(`videobook: ${warning}\n`);
+    await running.ready;
+    const client = await connect(running.mcpUrl);
+    return {
+        client,
+        temporary: true,
+        async close() {
+            await client.close();
+            await running.close();
+        },
+    };
+}
+async function openOwnerSession() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    refuseUnresponsive(owner);
+    if (owner.kind !== "running")
+        return temporaryOwner();
+    const client = await connect(`${owner.record.url}/mcp`);
+    return { client, temporary: false, close: () => client.close() };
+}
+function textOf(result) {
+    return result.content.flatMap((item) => item.type === "text" ? [item.text] : [JSON.stringify(item)]);
+}
+function parseJsonObject(text) {
+    if (!text)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value !== "" ? value : null;
+}
+function jobReference(first) {
+    const value = first?.job_id;
+    if (typeof value === "number" && Number.isInteger(value) && value > 0)
+        return { job_ids: [value] };
+    if (typeof value === "string" && value !== "")
+        return { job_keys: [value] };
+    return null;
+}
+function parseSnapshot(result) {
+    if (result.isError)
+        return null;
+    const rows = JSON.parse(textOf(result)[0] ?? "[]");
+    const job = Array.isArray(rows) ? rows[0] : undefined;
+    if (!job || typeof job.state !== "string")
+        return null;
+    return { state: job.state, error: typeof job.error?.message === "string" ? job.error.message : null };
+}
+async function jobSnapshot(client, bookId, reference) {
+    const result = await client.callTool({ name: "list_jobs", arguments: { book_id: bookId, ...reference } });
+    return parseSnapshot(result);
+}
+function reportJob(label, job) {
+    if (job.state === "done") {
+        process.stderr.write(`Job ${label} completed.\n`);
+        return 0;
+    }
+    process.stderr.write(`Job ${label} ${job.state}${job.error ? `: ${job.error}` : ""}\n`);
+    return 1;
+}
+async function waitForJob(client, bookId, reference, label, timeoutSeconds) {
+    process.stderr.write(`Waiting for job ${label}...\n`);
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    let job = await jobSnapshot(client, bookId, reference);
+    while (job && !FINISHED_JOB_STATES.has(job.state) && Date.now() < deadline) {
+        await delay(JOB_POLL_MS);
+        job = await jobSnapshot(client, bookId, reference);
+    }
+    if (!job) {
+        process.stderr.write(`Job ${label} is not tracked by the server; check it with list_jobs.\n`);
+        return 0;
+    }
+    if (FINISHED_JOB_STATES.has(job.state))
+        return reportJob(label, job);
+    process.stderr.write(`Job ${label} did not finish within ${timeoutSeconds} s.\n`);
+    return 1;
+}
+async function waitForAsset(client, bookId, assetId, timeoutSeconds) {
+    process.stderr.write(`Waiting for asset ${assetId}...\n`);
+    const result = await client.callTool({ name: "wait_for_asset_ready", arguments: { book_id: bookId, asset_id: assetId, timeout_seconds: timeoutSeconds } }, { timeout: timeoutSeconds * 1000 + REQUEST_GRACE_MS });
+    for (const line of textOf(result))
+        process.stdout.write(`${line}\n`);
+    return result.isError ? 1 : 0;
+}
+async function waitForOutcome(session, flags, args, first) {
+    const reference = jobReference(first);
+    const assetId = stringField(first, "asset_id");
+    const bookId = typeof args.book_id === "string" ? args.book_id : null;
+    const status = stringField(first, "status");
+    if (!reference || (status && SETTLED_STATUSES.has(status)))
+        return 0;
+    if (!flags.wait && !session.temporary)
+        return 0;
+    if (assetId && bookId)
+        return waitForAsset(session.client, bookId, assetId, flags.timeoutSeconds);
+    if (!bookId) {
+        process.stderr.write(`Job ${String(first?.job_id)} was queued; pass book_id to wait for it.\n`);
+        return 0;
+    }
+    return waitForJob(session.client, bookId, reference, String(first?.job_id), flags.timeoutSeconds);
+}
+async function callOnce(session, flags, tool, args) {
+    try {
+        return await session.client.callTool({ name: tool, arguments: args }, { timeout: flags.timeoutSeconds * 1000 + REQUEST_GRACE_MS });
+    }
+    catch (error) {
+        process.stderr.write(`videobook run: ${error instanceof Error ? error.message : String(error)}\n`);
+        return null;
+    }
+}
+export async function runToolCommand(flags, tool, args) {
+    const session = await openOwnerSession();
+    try {
+        const result = await callOnce(session, flags, tool, args);
+        if (!result)
+            return 1;
+        const lines = textOf(result);
+        const stream = result.isError ? process.stderr : process.stdout;
+        for (const line of lines)
+            stream.write(`${line}\n`);
+        if (result.isError)
+            return 1;
+        return await waitForOutcome(session, flags, args, parseJsonObject(lines[0]));
+    }
+    finally {
+        await session.close();
+    }
+}
+function listingFromJsonSchema(tool) {
+    const properties = Object.keys(tool.inputSchema.properties ?? {});
+    const required = new Set(tool.inputSchema.required ?? []);
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        required: properties.filter((key) => required.has(key)),
+        optional: properties.filter((key) => !required.has(key)),
+    };
+}
+function localListings() {
+    return getAllToolDefs(scopedEngine, bookManager).map((def) => {
+        const schema = z.object(def.schema).toJSONSchema();
+        const required = new Set(schema.required ?? []);
+        const keys = Object.keys(def.schema);
+        return {
+            name: def.name,
+            ...(def.description ? { description: def.description } : {}),
+            required: keys.filter((key) => required.has(key)),
+            optional: keys.filter((key) => !required.has(key)),
+        };
+    });
+}
+async function ownerListings(owner) {
+    if (owner.kind !== "running")
+        return null;
+    const client = await connect(`${owner.record.url}/mcp`);
+    try {
+        return (await client.listTools()).tools.map(listingFromJsonSchema);
+    }
+    finally {
+        await client.close();
+    }
+}
+function renderListing(listing) {
+    const params = [...listing.required.map((key) => `<${key}>`), ...listing.optional.map((key) => `[${key}]`)].join(" ");
+    const head = params ? `${listing.name} ${params}` : listing.name;
+    return listing.description ? `${head}\n    ${listing.description}` : head;
+}
+export async function runToolsCommand() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    refuseUnresponsive(owner);
+    const listings = await ownerListings(owner) ?? localListings();
+    for (const listing of listings)
+        process.stdout.write(`${renderListing(listing)}\n`);
+    return 0;
+}
+export async function runGcBooksCommand() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    if (owner.kind !== "none") {
+        process.stderr.write(`videobook is running at ${owner.record.url} (pid ${owner.record.pid}); stop it before collecting catalog garbage.\n`);
+        return 1;
+    }
+    try {
+        const reports = await gcLibraryCatalogs(bookManager);
+        process.stdout.write(`${JSON.stringify({ catalogs: reports }, null, 2)}\n`);
+        return 0;
+    }
+    finally {
+        await bookManager.close();
+    }
+}

package/dist/cli/serve-command.js

@@ -0,0 +1,62 @@
+import { resolvePort } from "./args.js";
+import { onePasswordSummary, onePasswordWarnings } from "./key-report.js";
+import { openInBrowser } from "./open-browser.js";
+import { logger } from "../logger.js";
+import { SERVER_VERSION } from "../server.js";
+import { ServerAlreadyRunningError } from "../server-lock.js";
+import { installSignalHandlers, startServer } from "../serve.js";
+function uiLine(running) {
+    if (running.uiStatus === "served")
+        return `${running.url}/`;
+    if (running.uiStatus === "disabled")
+        return "off (--headless)";
+    return `not built at ${running.uiDir}; serving MCP and API only`;
+}
+function printBanner(running) {
+    const keys = onePasswordSummary();
+    process.stdout.write([
+        `videobook ${SERVER_VERSION}`,
+        `Library  ${running.libraryDir}`,
+        `UI       ${uiLine(running)}`,
+        `MCP      ${running.mcpUrl}`,
+        ...(keys ? [`Keys     ${keys}`] : []),
+        "Agents   claude mcp add videobook -- videobook mcp",
+        "",
+    ].join("\n"));
+    for (const warning of onePasswordWarnings())
+        process.stderr.write(`videobook: ${warning}\n`);
+}
+function reportStartupFailure(error, port) {
+    if (error instanceof ServerAlreadyRunningError) {
+        process.stderr.write(`${error.message}\n`);
+        return 1;
+    }
+    logger.error("startup-failed", { error, port });
+    if (error?.code === "EADDRINUSE") {
+        process.stderr.write(`Port ${port} is already in use by another process; pass --port <n>.\n`);
+    }
+    return 1;
+}
+function hydrationFailure(running) {
+    return running.ready.then(() => new Promise(() => undefined), async (error) => {
+        logger.error("startup-failed", { error, port: running.port });
+        await running.close().catch(() => undefined);
+        return 1;
+    });
+}
+export async function runServeCommand(flags) {
+    const port = resolvePort(process.env);
+    const starting = startServer({ port, ui: flags.ui });
+    const stopped = new Promise((resolveStop) => installSignalHandlers(starting, resolveStop));
+    let running;
+    try {
+        running = await starting;
+    }
+    catch (error) {
+        return reportStartupFailure(error, port);
+    }
+    printBanner(running);
+    if (flags.open && running.uiStatus === "served")
+        openInBrowser(`${running.url}/`);
+    return Promise.race([stopped, hydrationFailure(running)]);
+}

package/dist/cli/setup-command.js

@@ -0,0 +1,60 @@
+import { readEnvValues, updateEnvFile } from "../env-file.js";
+import { MANAGED_ENV_KEYS, getDefaultSecretStore } from "../env-secrets.js";
+import { OP_TOKEN_SETTING, OP_VAULT_SETTING, listVaultItemTitles, opErrorMessage, resolveServiceToken, } from "../one-password.js";
+const AMBIENT_TOKEN_VARIABLE = "OP_SERVICE_ACCOUNT_TOKEN";
+function savedSetting(name, file) {
+    return process.env[name]?.trim() || file[name]?.trim() || null;
+}
+function chosenVault(flags, file) {
+    return flags.vault?.trim() || savedSetting(OP_VAULT_SETTING, file);
+}
+function chosenToken(flags, file) {
+    const explicit = flags.token?.trim() || savedSetting(OP_TOKEN_SETTING, file);
+    if (explicit)
+        return explicit;
+    return process.env[AMBIENT_TOKEN_VARIABLE]?.trim() ? `env:${AMBIENT_TOKEN_VARIABLE}` : null;
+}
+function describeToken(token) {
+    if (!token)
+        return "op's own sign-in";
+    const resolved = resolveServiceToken(token, process.env);
+    if (resolved.source === "literal")
+        return "a literal token (stored in the file; prefer env:VAR)";
+    return resolved.value ? token : `${token}, which is not set in this shell`;
+}
+async function removeSettings(envPath) {
+    await updateEnvFile(envPath, { [OP_VAULT_SETTING]: null, [OP_TOKEN_SETTING]: null });
+    process.stdout.write(`Removed ${OP_VAULT_SETTING} and ${OP_TOKEN_SETTING} from ${envPath}\n`);
+    return 0;
+}
+function verifyVault(vault, token) {
+    const value = token ? resolveServiceToken(token, process.env).value : null;
+    try {
+        const titles = listVaultItemTitles(vault, process.env, value);
+        const found = MANAGED_ENV_KEYS.filter((key) => titles.has(key));
+        const missing = MANAGED_ENV_KEYS.filter((key) => !titles.has(key));
+        process.stdout.write(`1Password vault ${vault}: ${found.length} of ${MANAGED_ENV_KEYS.length} videobook keys found\n`);
+        if (missing.length > 0)
+            process.stdout.write(`Not in the vault: ${missing.join(", ")}\n`);
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(`Could not list 1Password vault ${vault}: ${opErrorMessage(error, value)}\n`);
+        return 1;
+    }
+}
+export async function runSetupCommand(flags) {
+    const envPath = getDefaultSecretStore().envPath();
+    if (flags.remove)
+        return removeSettings(envPath);
+    const file = readEnvValues(envPath);
+    const vault = chosenVault(flags, file);
+    if (!vault) {
+        process.stderr.write("setup 1password needs --op-vault <vault>, the vault whose items are named after videobook's keys\n");
+        return 2;
+    }
+    const token = chosenToken(flags, file);
+    await updateEnvFile(envPath, { [OP_VAULT_SETTING]: vault, [OP_TOKEN_SETTING]: token });
+    process.stdout.write(`Saved ${OP_VAULT_SETTING}=${vault} and the token setting (${describeToken(token)}) to ${envPath}\n`);
+    return flags.verify ? verifyVault(vault, token) : 0;
+}

package/dist/cli/stdio-guard.js

@@ -0,0 +1,8 @@
+import { Console } from "node:console";
+export function redirectConsoleToStderr() {
+    Object.defineProperty(globalThis, "console", {
+        value: new Console({ stdout: process.stderr, stderr: process.stderr }),
+        writable: true,
+        configurable: true,
+    });
+}

package/dist/cold-open-model.js

@@ -0,0 +1,7 @@
+export function coldOpenRangeError(start, end, duration) {
+    if (![start, end, duration].every(Number.isFinite) || duration < 0.5)
+        return "Choose a playable video at least 0.5 seconds long.";
+    if (start < 0 || end > duration || end - start < 0.5 - 0.000001)
+        return "Choose a highlight at least 0.5 seconds long within the video.";
+    return null;
+}