@odori/cli 0.0.2

package/src/cli.ts

@@ -0,0 +1,319 @@
+import {createRequire} from "node:module";
+import {log} from "./log";
+import {addCommand, registryCommand} from "./commands/add";
+import {diffCommand, updateCommand} from "./commands/update";
+import {devCommand} from "./commands/dev";
+import {doctorCommand} from "./commands/doctor";
+import {installCommand} from "./binaries";
+import {exportCommand, jobsCommand} from "./commands/exportVideo";
+import {initCommand} from "./commands/init";
+import {inspectCommand} from "./commands/inspect";
+import {listCommand} from "./commands/list";
+import {newCommand} from "./commands/new";
+import {stillCommand} from "./commands/still";
+import {testCommand} from "./commands/test";
+
+type Flags = Record<string, string | boolean>;
+
+export const parseArgs = (argv: string[]): {command: string; positionals: string[]; flags: Flags} => {
+  const [command = "help", ...rest] = argv;
+  const positionals: string[] = [];
+  const flags: Flags = {};
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token.startsWith("--")) {
+      // `--name=value` and `--name value` are the same flag written two ways,
+      // and a reader who has used any other CLI expects both to work.
+      const equals = token.indexOf("=");
+      if (equals > 2) {
+        flags[token.slice(2, equals)] = token.slice(equals + 1);
+        continue;
+      }
+      const name = token.slice(2);
+      const next = rest[index + 1];
+      if (next === undefined || next.startsWith("--")) flags[name] = true;
+      else {
+        flags[name] = next;
+        index += 1;
+      }
+    } else {
+      positionals.push(token);
+    }
+  }
+  return {command, positionals, flags};
+};
+
+/** A flag that means a count or an index has to actually be one. */
+const numberFlag = (flags: Flags, name: string): number | undefined => {
+  const value = flags[name];
+  if (value === undefined) return undefined;
+  const parsed = typeof value === "string" ? Number(value) : Number.NaN;
+  if (!Number.isFinite(parsed)) throw new Error(`--${name} needs a number, got ${String(value)}`);
+  return parsed;
+};
+
+const parseInput = (flags: Flags): Record<string, unknown> | undefined => {
+  if (typeof flags.input !== "string") return undefined;
+  try {
+    return JSON.parse(flags.input) as Record<string, unknown>;
+  } catch (error) {
+    // A raw parser message names a position in a string the reader cannot see,
+    // and never mentions which flag it came from.
+    const preview = flags.input.length > 40 ? `${flags.input.slice(0, 40)}…` : flags.input;
+    throw new Error(
+      `--input is not valid JSON: ${(error as Error).message}. Received: ${preview}\n` +
+        `A shell eats double quotes, so wrap the whole value in single quotes: --input '{"headline":"Ship it"}'`,
+    );
+  }
+};
+
+/**
+ * What each command accepts. An unknown flag is a typo or a wrong assumption,
+ * and either way ignoring it silently means the command runs as though the
+ * flag were never written, which is the most expensive way to find out.
+ */
+const COMMAND_FLAGS: Record<string, string[]> = {
+  dev: ["port", "open", "no-open"],
+  init: [],
+  doctor: [],
+  install: [],
+  new: ["blank"],
+  add: ["force", "dry-run"],
+  registry: [],
+  diff: ["full"],
+  update: ["force"],
+  list: [],
+  inspect: ["json", "input"],
+  still: ["frame", "output", "input"],
+  test: ["json"],
+  export: ["output", "input", "concurrency", "preset", "format", "no-frame-skip", "retry"],
+  jobs: [],
+  help: [],
+};
+
+/** Levenshtein distance, for "did you mean". Short strings, so cost is nothing. */
+const distance = (left: string, right: string): number => {
+  const rows = Array.from({length: left.length + 1}, (_, index) => [index, ...(Array(right.length).fill(0) as number[])]);
+  for (let column = 0; column <= right.length; column += 1) rows[0][column] = column;
+  for (let row = 1; row <= left.length; row += 1) {
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      rows[row][column] = Math.min(
+        rows[row - 1][column] + 1,
+        rows[row][column - 1] + 1,
+        rows[row - 1][column - 1] + cost,
+      );
+    }
+  }
+  return rows[left.length][right.length];
+};
+
+const nearest = (value: string, candidates: string[]): string | undefined => {
+  const ranked = candidates
+    .map((candidate) => ({candidate, score: distance(value, candidate)}))
+    .sort((left, right) => left.score - right.score)[0];
+  // Two edits is a typo. Further than that is a different word.
+  return ranked && ranked.score <= 2 ? ranked.candidate : undefined;
+};
+
+export const checkFlags = (command: string, flags: Flags): void => {
+  const allowed = COMMAND_FLAGS[command];
+  if (!allowed) return;
+  for (const name of Object.keys(flags)) {
+    if (allowed.includes(name) || name === "help") continue;
+    const suggestion = nearest(name, allowed);
+    throw new Error(
+      `Unknown flag --${name} for "odori ${command}".` +
+        (suggestion
+          ? ` Did you mean --${suggestion}?`
+          : allowed.length > 0
+            ? ` It accepts: ${allowed.map((item) => `--${item}`).join(", ")}`
+            : " It takes no flags."),
+    );
+  }
+};
+
+const USAGE: Record<string, string> = {
+  dev: `odori dev [--port <n>] [--no-open]
+  Discover project resources and start Studio.`,
+  init: `odori init
+  Add videos/ and odori.config.ts to a project.`,
+  doctor: `odori doctor
+  Check Node, React, the source root, Chrome, FFmpeg, and the generated cache.`,
+  install: `odori install
+  Download the pinned Chrome and FFmpeg into the shared cache, so a render
+  never waits and every machine encodes with the same build. Run it in a
+  Dockerfile layer or a CI setup step.`,
+  new: `odori new <name> [--blank]
+  Generate a video.tsx entry. --blank writes plain markup instead of composing
+  the components the project has installed.`,
+  add: `odori add <components...> [--force] [--dry-run]
+  Install editable component source, fetched from the registry and cached.
+  --force replaces local edits. --dry-run lists the files and writes nothing.`,
+  registry: `odori registry
+  List available registry components and cues.`,
+  diff: `odori diff [components] [--full]
+  Compare installed components with upstream.`,
+  update: `odori update [components] [--force]
+  Apply upstream component changes.`,
+  list: `odori list
+  Print discovered video ids and formats.`,
+  inspect: `odori inspect <id> [--json] [--input <json>]
+  Show resolved layout, inputs, scenes, and assets.`,
+  still: `odori still <id> --frame <n> [--output <path>] [--input <json>]
+  Render one deterministic frame.`,
+  test: `odori test [id] [--json]
+  Validate contracts and representative frames. --json emits one object per
+  check, for CI.`,
+  export: `odori export <id> [--output <path>] [--input <json>] [--concurrency <n>]
+             [--preset <name>] [--format <name>] [--no-frame-skip] [--retry <job>]
+  Render and encode a distributable file. --format is mp4, webm, prores, gif,
+  or png; without it the output's extension decides, and mp4 is the default.`,
+  jobs: `odori jobs
+  List export jobs and their status.`,
+};
+
+const HELP = `odori - build videos like applications
+
+Usage
+  odori dev [--port 4300]          Discover project resources and start Studio
+  odori init                       Add videos/ and odori.config.ts to a project
+  odori doctor                     Check everything a render and an encode need
+  odori install                    Download the pinned Chrome and FFmpeg
+  odori new <name>                 Generate a video.tsx entry
+  odori add <components...>        Install editable component source
+  odori registry                   List available registry components
+  odori diff [components]          Compare installed components with upstream
+  odori update [components]        Apply upstream component changes
+  odori list                       Print discovered video ids and formats
+  odori inspect <id> [--json]      Show resolved layout, inputs, scenes, assets
+  odori still <id> --frame 120     Render one deterministic frame
+  odori test [id] [--json]         Validate contracts and representative frames
+  odori export <id> [--output f]   Render and encode a distributable file
+  odori jobs                       List export jobs and their status
+
+Options
+  --input '{"headline":"..."}'     Serializable input for the video schema
+  --output <path>                  Output path for still and export
+  --force                          Replace locally modified component source
+  --concurrency <n>                Parallel render workers for export
+  --preset <name>                  x264 preset for export, default medium
+  --format <name>                  mp4, webm, prores, gif, or png
+  --no-frame-skip                  Capture every frame, even unchanged ones
+  --retry <job id>                 Re-run a recorded job from its frozen manifest
+  --no-open                        Start dev without opening Studio in a browser
+  --json                           Machine readable output, for inspect and test
+
+Run "odori <command> --help" for one command, or "odori doctor" to check setup.
+`;
+
+/** The published version, so a bug report can say which one. */
+const cliVersion = (): string => {
+  try {
+    const require = createRequire(import.meta.url);
+    return (require("../package.json") as {version: string}).version;
+  } catch {
+    return "unknown";
+  }
+};
+
+export const run = async (argv: string[]): Promise<number> => {
+  const {command, positionals, flags} = parseArgs(argv);
+  try {
+    if (command === "--version" || command === "-v" || command === "version") {
+      log.info(`odori ${cliVersion()} (node ${process.version})`);
+      return 0;
+    }
+    // Asking a command for help is asking about it, not running it with
+    // whatever the defaults happen to be.
+    if (flags.help === true && USAGE[command]) {
+      log.info(USAGE[command]);
+      return 0;
+    }
+    checkFlags(command, flags);
+
+    switch (command) {
+      case "dev": {
+        const server = await devCommand({
+          port: numberFlag(flags, "port"),
+          open: flags["no-open"] === true ? false : flags.open === true ? true : undefined,
+        });
+        await new Promise<void>((resolveDev) => {
+          const stop = () => {
+            void server.close().then(() => resolveDev());
+          };
+          process.on("SIGINT", stop);
+          process.on("SIGTERM", stop);
+        });
+        return 0;
+      }
+      case "init":
+        await initCommand();
+        return 0;
+      case "doctor":
+        return await doctorCommand();
+      case "install":
+        return await installCommand();
+      case "new":
+        await newCommand(positionals[0] ?? "", {blank: flags.blank === true});
+        return 0;
+      case "add":
+        await addCommand(positionals, {force: flags.force === true, dryRun: flags["dry-run"] === true});
+        return 0;
+      case "registry":
+        await registryCommand();
+        return 0;
+      case "diff":
+        await diffCommand(positionals, {full: flags.full === true});
+        return 0;
+      case "update":
+        await updateCommand(positionals, {force: flags.force === true});
+        return 0;
+      case "list":
+        await listCommand();
+        return 0;
+      case "inspect":
+        await inspectCommand(positionals[0] ?? "", {json: flags.json === true, input: parseInput(flags)});
+        return 0;
+      case "still":
+        await stillCommand(positionals[0] ?? "", {
+          frame: numberFlag(flags, "frame") ?? 0,
+          output: typeof flags.output === "string" ? flags.output : undefined,
+          input: parseInput(flags),
+        });
+        return 0;
+      case "test":
+        await testCommand(positionals[0], {json: flags.json === true});
+        return 0;
+      case "export":
+        await exportCommand(positionals[0] ?? "", {
+          output: typeof flags.output === "string" ? flags.output : undefined,
+          input: parseInput(flags),
+          concurrency: numberFlag(flags, "concurrency"),
+          preset: typeof flags.preset === "string" ? flags.preset : undefined,
+          format: typeof flags.format === "string" ? flags.format : undefined,
+          skipUnchangedFrames: flags["no-frame-skip"] === true ? false : undefined,
+          retry: typeof flags.retry === "string" ? flags.retry : undefined,
+        });
+        return 0;
+      case "jobs":
+        await jobsCommand();
+        return 0;
+      case "help":
+      case "--help":
+      case "-h":
+        log.info(HELP);
+        return 0;
+      default: {
+        const commands = Object.keys(COMMAND_FLAGS).filter((name) => name !== "help");
+        const suggestion = nearest(command, commands);
+        log.error(`Unknown command "${command}".${suggestion ? ` Did you mean "odori ${suggestion}"?` : ""}`);
+        log.info(HELP);
+        return 1;
+      }
+    }
+  } catch (error) {
+    log.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+};

package/src/commands/add.ts

@@ -0,0 +1,151 @@
+import {mkdir, readFile, writeFile} from "node:fs/promises";
+import {existsSync} from "node:fs";
+import {relative, resolve} from "node:path";
+import {hashString} from "odori";
+import {loadConfig} from "../config";
+import {log} from "../log";
+import {registerCueInBrand} from "../brand-file";
+import {normalizeComponentName, registryUrl, resolveItem, resolveRegistry, verifyIntegrity} from "../registry-source";
+import {readProvenance, writeProvenance} from "./update";
+
+/**
+ * Installation copies source into the project. Provenance is recorded so the
+ * CLI can report upstream changes, but a locally modified component is never
+ * replaced without an explicit decision.
+ */
+export const addCommand = async (names: string[], options: {force?: boolean; dryRun?: boolean} = {}) => {
+  if (names.length === 0) throw new Error("Name at least one component, for example @odori/title-reveal.");
+  const config = await loadConfig(process.cwd());
+  const source = await resolveRegistry(config);
+  const registry = source.items;
+  const provenance = await readProvenance(config);
+
+  // Say where the source is coming from before writing any of it. A cached or
+  // bundled registry installs an older component than the site shows, and that
+  // is worth one line rather than a puzzled bug report.
+  if (source.origin === "network") log.detail(`registry: ${source.detail}`);
+  else if (source.origin === "cache") log.detail(`registry: cached copy of ${registryUrl(config)} (offline)`);
+  else log.warn(`registry: the copy built into this CLI. It may be older than ${registryUrl(config)}.`);
+
+  const queue = [...names.map(normalizeComponentName)];
+  const installed: string[] = [];
+
+  while (queue.length > 0) {
+    const name = queue.shift()!;
+    if (installed.includes(name)) continue;
+    const component = registry.find((item) => item.name === name);
+    if (!component) {
+      throw new Error(`Unknown component "${name}". Known: ${registry.map((item) => item.namespaced).join(", ")}`);
+    }
+    queue.push(...component.registryDependencies.map(normalizeComponentName));
+    // A contract that names a cue is a dependency like any other: install the
+    // component that provides it rather than leaving a silent gap.
+    for (const cue of component.contract.requires.audio) {
+      const provider = registry.find((item) => item.cue?.name === cue);
+      if (provider) queue.push(provider.name);
+      else log.warn(`${component.namespaced} needs a "${cue}" cue and no registry entry provides one.`);
+    }
+
+    // The item document carries the file contents; the index does not.
+    const {item} = await resolveItem(config, component.name);
+    // Before anything is written: the bytes have to be the bytes the registry
+    // said it was serving.
+    verifyIntegrity(item);
+
+    const target = resolve(config.root, config.componentsDir, component.name);
+    const hashes: Record<string, string> = {};
+
+    // What will be written, listed before it is. Installing source into
+    // somebody's repository should never be the first they hear of a path.
+    for (const file of item.files) {
+      const destination = resolve(config.root, file.target);
+      const exists = existsSync(destination);
+      log.detail(`  ${exists ? "replace" : "create "} ${relative(config.root, destination)}`);
+    }
+    if (options.dryRun) {
+      installed.push(component.name);
+      continue;
+    }
+
+    await mkdir(target, {recursive: true});
+
+    for (const file of item.files) {
+      const name = file.path.split("/").pop() ?? file.path;
+      const destination = resolve(config.root, file.target);
+      hashes[name] = hashString(file.content);
+
+      if (existsSync(destination) && !options.force) {
+        const current = hashString(await readFile(destination, "utf8"));
+        const recorded = provenance[component.name]?.hashes[name];
+        if (current !== recorded) {
+          log.warn(`${relative(config.root, destination)} was modified locally. Keeping your version. Use --force to replace it.`);
+          continue;
+        }
+      }
+      await mkdir(resolve(destination, ".."), {recursive: true});
+      await writeFile(destination, file.content, "utf8");
+    }
+
+    provenance[component.name] = {
+      source: component.namespaced,
+      version: "0.1.0",
+      installedAt: new Date().toISOString(),
+      hashes,
+    };
+    installed.push(component.name);
+    log.success(`${component.namespaced} to ${relative(config.root, target)}/`);
+    if (component.kind === "cue" && component.cue) {
+      log.detail(
+        `  ${component.family} · ${component.contract.recommendedDurationInFrames} frames · registers "${component.cue.name}"`,
+      );
+      // A cue that the brand does not know is silent, so wire it here rather
+      // than leaving an installed component that does nothing.
+      const registered = await registerCueInBrand(config, component.cue, component.name);
+      if (registered?.already) {
+        log.detail(`  "${component.cue.name}" is already registered in ${registered.file}`);
+      } else if (registered) {
+        log.detail(`  registered "${component.cue.name}" in ${registered.file}`);
+      } else {
+        log.warn(`  No brand with an audio.cues block found. Add it yourself:`);
+        log.detail(`    import {${component.cue.export}} from "./components/${component.name}/${component.name}";`);
+        log.detail(`    audio: {cues: {"${component.cue.name}": ${component.cue.export}()}}`);
+      }
+    } else {
+      log.detail(
+        `  ${component.family} · recommended ${component.contract.recommendedDurationInFrames} frames · ${component.contract.aspectRatios.join(", ")}`,
+      );
+    }
+  }
+
+  if (options.dryRun) {
+    log.detail("Nothing was written. Drop --dry-run to install.");
+    return;
+  }
+  await writeProvenance(config, provenance);
+  log.detail("Run odori dev to preview the installed component fixtures.");
+};
+
+export const registryCommand = async () => {
+  const config = await loadConfig(process.cwd());
+  const source = await resolveRegistry(config);
+  const registry = source.items;
+  const families = [...new Set(registry.map((component) => component.family))];
+  for (const family of families) {
+    log.title(family);
+    for (const component of registry.filter((item) => item.family === family)) {
+      log.info(`  ${component.namespaced.padEnd(26)} ${component.description}`);
+      log.detail(
+        component.kind === "cue" && component.cue
+          ? `    sound · ${component.contract.recommendedDurationInFrames} frames · registers "${component.cue.name}"`
+          : `    ${component.contract.aspectRatios.join(", ")} · min ${component.contract.minimumDurationInFrames} frames · reduced motion: ${component.contract.reducedMotion}`,
+      );
+    }
+  }
+  log.detail(
+    source.origin === "network"
+      ? `${registry.length} entries from ${source.detail}`
+      : source.origin === "cache"
+        ? `${registry.length} entries from the cache (offline). Latest is at ${registryUrl(config)}.`
+        : `${registry.length} entries from the copy built into this CLI. Latest is at ${registryUrl(config)}.`,
+  );
+};

package/src/commands/dev.ts

@@ -0,0 +1,160 @@
+import {resolve} from "node:path";
+import {readFile} from "node:fs/promises";
+import type {IncomingMessage, ServerResponse} from "node:http";
+import {loadConfig} from "../config";
+import {log} from "../log";
+import {createJob, listJobs, readJob} from "../jobs";
+import {discoverProject} from "../discovery";
+import {findVideo, freezeManifest, loadVideos, outputName} from "../project";
+import {renderStill} from "../render";
+import {openInBrowser, shouldOpenBrowser} from "../open";
+import {startStudioServer} from "../server";
+import {cancelJob, runJob} from "./exportVideo";
+import {compileInBrowser, targetFor} from "./shared";
+
+const readBody = async (request: IncomingMessage): Promise<Record<string, unknown>> => {
+  const chunks: Buffer[] = [];
+  for await (const chunk of request) chunks.push(chunk as Buffer);
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8")) as Record<string, unknown>;
+};
+
+const json = (response: ServerResponse, status: number, payload: unknown) => {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json");
+  response.end(JSON.stringify(payload));
+};
+
+/**
+ * Studio previews without encoding. These endpoints exist so an explicit
+ * export action in the browser reaches the same queue and render worker the
+ * CLI uses.
+ */
+export const devCommand = async (options: {port?: number; root?: string; open?: boolean} = {}) => {
+  const config = await loadConfig(options.root ?? process.cwd());
+  const context = async () => {
+    const graph = await discoverProject(config);
+    return {graph, videos: await loadVideos(graph)};
+  };
+
+  const server = await startStudioServer(config, {
+    port: options.port ?? config.port,
+    middleware: (vite) => {
+      vite.middlewares.use("/__odori", (request, response, next) => {
+        const url = request.url ?? "/";
+        void (async () => {
+          try {
+            if (request.method === "POST" && url.startsWith("/still")) {
+              const body = await readBody(request);
+              const {graph, videos} = await context();
+              const video = findVideo(videos, String(body.videoId));
+              const input = (body.input ?? {}) as Record<string, unknown>;
+              const compiled = await compileInBrowser(origin, targetFor(video, input), config);
+              const {manifest, prepared} = await freezeManifest(
+                {...video, durationInFrames: compiled.durationInFrames},
+                graph,
+                config,
+                input,
+                {scenes: compiled.scenes, audio: compiled.audio},
+              );
+              const frame = Number(body.frame ?? 0);
+              // A clipboard grab is transient, so it renders into the generated
+              // directory instead of littering the export directory.
+              const inline = body.inline === true;
+              const directory = inline ? config.outDir : config.exportDir;
+              const file = resolve(config.root, `${directory}/${outputName(video.entry.metadata.id)}-${frame}.png`);
+              await renderStill(
+                origin,
+                targetFor(
+                  {...video, durationInFrames: manifest.format.durationInFrames},
+                  manifest.input as Record<string, unknown>,
+                  prepared,
+                  manifest.audio,
+                ),
+                frame,
+                file,
+                config,
+              );
+              if (inline) {
+                response.statusCode = 200;
+                response.setHeader("content-type", "image/png");
+                response.end(await readFile(file));
+                return;
+              }
+              json(response, 200, {id: "still", status: "ready", progress: 1, output: file});
+              return;
+            }
+
+            if (request.method === "POST" && url.startsWith("/exports")) {
+              const body = await readBody(request);
+              const {graph, videos} = await context();
+              const video = findVideo(videos, String(body.videoId));
+              const input = (body.input ?? {}) as Record<string, unknown>;
+              const compiled = await compileInBrowser(origin, targetFor(video, input), config);
+              const {manifest} = await freezeManifest(
+                {...video, durationInFrames: compiled.durationInFrames},
+                graph,
+                config,
+                input,
+                {scenes: compiled.scenes, audio: compiled.audio},
+              );
+              const output = resolve(config.root, `${config.exportDir}/${outputName(video.entry.metadata.id)}.mp4`);
+              const record = await createJob(config, manifest, output);
+              json(response, 202, record.job);
+
+              void runJob(config, origin, record, video).catch((error) => {
+                log.error(`Export failed: ${error instanceof Error ? error.message : String(error)}`);
+              });
+              return;
+            }
+
+            if (request.method === "POST" && url.startsWith("/retry/")) {
+              const id = url.replace("/retry/", "").split("?")[0];
+              const record = await readJob(config, id);
+              const {videos} = await context();
+              const video = findVideo(videos, record.manifest.videoId);
+              json(response, 202, record.job);
+              void runJob(config, origin, record, video).catch((error) => {
+                log.error(`Retry failed: ${error instanceof Error ? error.message : String(error)}`);
+              });
+              return;
+            }
+
+            if (request.method === "POST" && url.startsWith("/cancel/")) {
+              const id = url.replace("/cancel/", "").split("?")[0];
+              const cancelled = cancelJob(id);
+              json(response, cancelled ? 202 : 404, {id, cancelled});
+              return;
+            }
+
+            if (request.method === "GET" && url.startsWith("/jobs/")) {
+              const id = url.replace("/jobs/", "").split("?")[0];
+              json(response, 200, (await readJob(config, id)).job);
+              return;
+            }
+
+            if (request.method === "GET" && url.startsWith("/jobs")) {
+              json(response, 200, await listJobs(config));
+              return;
+            }
+
+            next();
+          } catch (error) {
+            json(response, 500, {status: "failed", error: error instanceof Error ? error.message : String(error)});
+          }
+        })();
+      });
+    },
+  });
+
+  const origin = server.url;
+  // Views are routable, so name the one Studio starts on rather than leaving a
+  // bare origin that silently resolves to it.
+  const entry = `${origin}/videos`;
+  log.title("Odori Studio");
+  log.info(`  ${entry}`);
+  log.detail(`  ${server.graph.videos.length} videos, ${server.graph.previews.length} component previews`);
+  log.detail(`  watching ${config.videosDir}/`);
+  if (shouldOpenBrowser(options.open ?? config.open)) openInBrowser(entry);
+  return server;
+};