What is this PR for?

Today a note can only be run through a live server — you start the web server
(Jetty/REST/WebSocket) and drive it from the browser, or call the REST API of an
already-running instance. That ties every execution to a long-lived server
process, which is awkward for cron jobs, CI checks, and batch pipelines.

This PR adds a small CLI, bin/run-note.sh, that runs a single note headlessly
— no web server at all — in the spirit of papermill
for Jupyter. It assembles just the interpreter runtime, executes the note, saves
the result, and exits.

Usage

bin/run-note.sh -i <notePath> [-o <outputPath>] [-p <key> <value>]...

• -i — logical path of the note to run (e.g. /Demo, as shown in the note list). Required.
• -o — save the executed note to a new path instead of overwriting the input.
• -p — inject a parameter, substituted into ${key} / ${key=default} placeholders in the note. Repeatable.

Example:

bin/run-note.sh -i "/Python Tutorial/1. IPython Basic" -p date 2026-09-05 -o /out/report

How it works

NotebookRunner builds the notebook + interpreter runtime with manual dependency
injection (the same recipe the interpreter tests already use), so no Jetty/HK2 is
involved. The interpreter event server is still started — interpreters run as
separate processes and need it to call results back — but the web layer is not.
Paragraph output streams to stdout as the note runs, and the executed note is
saved through the normal NotebookRepo.

Behavior worth calling out

• Exit code: a paragraph left in a non-FINISHED state (error, abort, or
  skipped after an earlier failure) fails the run with a non-zero exit, so CI/batch
  callers can detect failures; a clean run exits 0.
• Clean shutdown: a one-shot CLI must not inherit the server's "run forever"
  assumption. On exit the process stops the interpreter processes, each
  RemoteScheduler's own thread pool, the event server, and ExecutorFactory's
  pools, then calls System.exit() as a backstop so a stray non-daemon thread
  cannot hang the JVM.
• stdout vs stderr: paragraph output goes to stdout (so > file captures only
  the results); the "saved / finished" summary goes to stderr.

Known limitation

Notes that drive other paragraphs programmatically via z.run() / z.runNote()
are not supported yet — that path executes paragraphs asynchronously and can
race the run's completion check. Straight top-to-bottom notes (the common batch
case) are unaffected. This is noted in HeadlessProcessListener and can be a
follow-up.

What type of PR is it?

Feature

What is the Jira issue?

• https://issues.apache.org/jira/browse/ZEPPELIN-5745

How should this be tested?

Automated — 19 unit/integration tests under notebook/cli/, including two that
launch bin/run-note.sh in a real separate JVM and assert the process exits
within a timeout (guarding against the JVM-hang class of bug) with the correct exit
code (0 on success, 1 on a failed paragraph):

mvn -pl zeppelin-server -am test -Dtest='NotebookRunner*Test'

Manual:

bin/run-note.sh -i /Demo

runs a note end to end, prints its output, saves the result, and returns to the
shell prompt on its own.

Screenshots (if appropriate)

Questions:

• Does the license files need to update? No — no new dependencies are introduced.
• Is there breaking changes for older versions? No — only new files are added; no existing code is modified.
• Does this needs documentation? A short docs page for run-note.sh would help and can follow.