@valerypopoff/rivet2-cli 2.0.10 → 2.1.0

package/bin/commands/run.js

@@ -1,8 +1,11 @@
-import { createProcessor, loadProjectFromFile } from '@valerypopoff/rivet2-node';
+import { createProcessor } from '@valerypopoff/rivet2-node';
+import { configDotenv } from 'dotenv';
 import { resolve } from 'node:path';
-import { parseJsonInputRecord, parseKeyValueInputRecord } from '../commandInputs.js';
+import { parseJsonInputRecord, parseJsonInputRecordFromFile, parseJsonKeyValueInputRecord, parseKeyValueInputRecord, throwIfConflictingInputSources, } from '../commandInputs.js';
+import { addDatasetOptions, addProviderOptions, loadProjectRuntime, throwIfInvalidGraph, throwIfNoMainGraph, withCliProcessorOptions, } from '../cliRuntime.js';
+import { shapeOutputs, validateOutputShapeOptions, writeJsonOutput } from '../output.js';
 export function makeCommand(y) {
-    return y
+    const command = addProviderOptions(y)
         .positional('projectFile', {
         describe: 'The project file to run',
         type: 'string',
@@ -16,17 +19,49 @@ export function makeCommand(y) {
         describe: 'Read inputs from stdin as JSON',
         type: 'boolean',
         default: false,
+    })
+        .option('inputs-file', {
+        describe: 'Read inputs from a JSON file',
+        type: 'string',
+    })
+        .option('input-json', {
+        describe: 'Adds a JSON input to the graph run using key=json',
+        type: 'string',
+        array: true,
+        default: [],
     })
         .option('include-cost', {
         describe: 'Include the total cost in the output',
         type: 'boolean',
         default: false,
+    })
+        .option('output-key', {
+        describe: 'Print only one named output Data Value wrapper',
+        type: 'string',
+    })
+        .option('unwrap-output', {
+        describe: 'Print only the .value field from one named output',
+        type: 'string',
+    })
+        .option('output-file', {
+        describe: 'Write the JSON output to a file instead of stdout',
+        type: 'string',
     })
         .option('context', {
         describe: 'Adds a context value to the graph run',
         type: 'string',
         array: true,
         default: [],
+    })
+        .option('context-json', {
+        describe: 'Adds a JSON context value using key=json',
+        type: 'string',
+        array: true,
+        default: [],
+    })
+        .option('context-file', {
+        describe: 'Read context values from a JSON file',
+        type: 'string',
     })
         .option('input', {
         describe: 'Adds an input to the graph run',
@@ -34,44 +69,60 @@ export function makeCommand(y) {
         array: true,
         default: [],
     });
+    return addDatasetOptions(command);
 }
 export async function run(args) {
-    try {
-        const projectPath = resolve(process.cwd(), args.projectFile);
-        const project = await loadProjectFromFile(projectPath);
-        if (!args.graphName && !project.metadata.mainGraphId) {
-            const validGraphs = Object.values(project.graphs).map((graph) => [graph.metadata.id, graph.metadata.name]);
-            const validGraphNames = validGraphs.map(([id, name]) => `- "${name}" (${id})`);
-            console.error(`No graph name provided, and project does not specify a main graph. Valid graphs are: \n${validGraphNames.join('\n')}\n\nUse either the graph's name or its ID. For example, \`rivet run my-project.rivet-project my-graph\` or \`rivet run my-project.rivet-project 1234abcd\``);
-            process.exit(1);
-        }
-        let inputs;
-        if (args.inputsStdin) {
-            const stdin = process.stdin;
-            stdin.setEncoding('utf8');
-            let inputText = '';
-            for await (const chunk of stdin) {
-                inputText += chunk;
-            }
-            inputs = parseJsonInputRecord(inputText, 'Input stdin');
-        }
-        else {
-            inputs = parseKeyValueInputRecord(args.input, 'input');
-        }
-        const contextValues = parseKeyValueInputRecord(args.context, 'context');
-        const { run } = createProcessor(project, {
-            graph: args.graphName,
-            inputs,
-            context: contextValues,
-        });
-        const outputs = await run();
-        if (!args.includeCost) {
-            delete outputs.cost;
-        }
-        console.log(JSON.stringify(outputs, null, 2));
+    configDotenv();
+    validateOutputShapeOptions(args);
+    const runtime = await loadProjectRuntime(args.projectFile, args);
+    throwIfNoMainGraph(runtime.project, args.graphName, runtime.projectPath, 'positional');
+    throwIfInvalidGraph(runtime.project, args.graphName, 'positional');
+    const { run: runProcessor } = createProcessor(runtime.project, withCliProcessorOptions(runtime, args, {
+        context: await readContext(args),
+        graph: args.graphName,
+        inputs: await readInputs(args),
+    }));
+    await writeJsonOutput(shapeOutputs(await runProcessor(), {
+        includeCost: args.includeCost,
+        outputKey: args.outputKey,
+        unwrapOutput: args.unwrapOutput,
+    }), args.outputFile);
+}
+async function readInputs(args) {
+    throwIfConflictingInputSources([
+        { enabled: args.inputsStdin, name: '--inputs-stdin' },
+        { enabled: args.inputsFile != null, name: '--inputs-file' },
+        { enabled: args.input.length > 0 || args.inputJson.length > 0, name: '--input/--input-json' },
+    ], 'input');
+    if (args.inputsStdin) {
+        return parseJsonInputRecord(await readStdin(), 'Input stdin');
+    }
+    if (args.inputsFile) {
+        return parseJsonInputRecordFromFile(resolve(process.cwd(), args.inputsFile), 'Input file');
     }
-    catch (err) {
-        console.error(err);
-        process.exit(1);
+    return {
+        ...parseKeyValueInputRecord(args.input, 'input'),
+        ...parseJsonKeyValueInputRecord(args.inputJson, 'input-json'),
+    };
+}
+async function readContext(args) {
+    throwIfConflictingInputSources([
+        { enabled: args.contextFile != null, name: '--context-file' },
+        { enabled: args.context.length > 0 || args.contextJson.length > 0, name: '--context/--context-json' },
+    ], 'context');
+    if (args.contextFile) {
+        return parseJsonInputRecordFromFile(resolve(process.cwd(), args.contextFile), 'Context file');
+    }
+    return {
+        ...parseKeyValueInputRecord(args.context, 'context'),
+        ...parseJsonKeyValueInputRecord(args.contextJson, 'context-json'),
+    };
+}
+async function readStdin() {
+    process.stdin.setEncoding('utf8');
+    let inputText = '';
+    for await (const chunk of process.stdin) {
+        inputText += chunk;
     }
+    return inputText;
 }

package/bin/commands/serve.js

@@ -1,18 +1,22 @@
-import { serve as serveHono } from '@hono/node-server';
 import { createProcessor, getSingleNodeStream, loadProjectFromFile } from '@valerypopoff/rivet2-node';
 import chalk from 'chalk';
-import didYouMean from 'didyoumean2';
 import { configDotenv } from 'dotenv';
 import { Hono } from 'hono';
-import { readdir, stat } from 'node:fs/promises';
-import { basename, dirname, extname, join, resolve } from 'node:path';
 import { parseJsonInputRecord } from '../commandInputs.js';
+import { addDatasetOptions, addProviderOptions, loadProjectRuntime, resolveServedGraphName, throwIfInvalidGraph, throwIfNoMainGraph, warnIfServerSavesDatasets, withCliProcessorOptions, withProviderProcessorOptions, } from '../cliRuntime.js';
+import { CliHttpError, addHttpOptions, createHttpMiddleware, formatListenUrl, jsonErrorResponse, jsonTimedResponse, startHttpServer, } from '../http.js';
+import { shapeOutputs } from '../output.js';
 export function makeCommand(y) {
-    return y
+    const command = addHttpOptions(addProviderOptions(y)
         .option('port', {
         describe: 'The port to serve on',
         type: 'number',
         default: 3000,
+    })
+        .option('host', {
+        describe: 'The host interface to bind to',
+        type: 'string',
+        default: '0.0.0.0',
     })
         .option('dev', {
         describe: 'Run in development mode: rereads the project file on each request',
@@ -29,25 +33,21 @@ export function makeCommand(y) {
         type: 'boolean',
         default: false,
     })
-        .option('openai-api-key', {
-        describe: 'The OpenAI API key to use for the project. If omitted, the environment variable OPENAI_API_KEY is used.',
-        type: 'string',
-        demandOption: false,
-    })
-        .option('openai-endpoint', {
-        describe: 'The OpenAI API endpoint to use for the project. If omitted, the environment variable OPENAI_ENDPOINT is used.',
+        .option('endpoint', {
+        describe: 'Expose a named endpoint alias using endpointName=graphNameOrId',
         type: 'string',
-        demandOption: false,
-    })
-        .option('openai-organization', {
-        describe: 'The OpenAI organization to use for the project. If omitted, the environment variable OPENAI_ORGANIZATION is used.',
-        type: 'string',
-        demandOption: false,
-    })
+        array: true,
+        default: [],
+    }));
+    return addDatasetOptions(command)
         .option('expose-cost', {
         describe: 'Expose the cost of the graph run in the response',
         type: 'boolean',
         default: false,
+    })
+        .option('unwrap-output', {
+        describe: 'Respond with only the .value field from one named output',
+        type: 'string',
     })
         .option('stream', {
         describe: 'Turns on streaming mode. Rivet events will be sent to the client using SSE (Server-Sent Events). If this is set to a Node ID or node title, only events for that node will be sent.',
@@ -66,94 +66,96 @@ export function makeCommand(y) {
     });
 }
 export async function serve(args) {
-    try {
-        configDotenv();
-        const app = new Hono();
-        const projectFilePath = await getProjectFile(args.projectFile);
-        const initialProject = await loadProjectFromFile(projectFilePath);
-        throwIfNoMainGraph(initialProject, args.graph, projectFilePath);
-        throwIfInvalidGraph(initialProject, args.graph);
-        if (args.stream != null) {
-            console.log('Streaming is enabled');
+    configDotenv();
+    const { app, projectFilePath, servedGraphName } = await createServeApp(args);
+    startHttpServer(app, args.host, args.port);
+    console.log(chalk.green(`Serving project file ${chalk.bold.white(projectFilePath)} at ${chalk.bold.white(formatListenUrl(args.host, args.port))}.\nServing graph "${chalk.bold.white(servedGraphName)}".`));
+}
+export async function createServeApp(args) {
+    const runtime = await loadProjectRuntime(args.projectFile, args);
+    const endpointAliases = parseEndpointAliases(args.endpoint, runtime.project);
+    throwIfNoMainGraph(runtime.project, args.graph, runtime.projectPath);
+    throwIfInvalidGraph(runtime.project, args.graph);
+    if (args.stream != null) {
+        console.log('Streaming is enabled');
+    }
+    warnIfServerSavesDatasets(args.saveDatasets, 'CLI server');
+    if (args.streamNode != null) {
+        if (args.stream == null) {
+            throw new Error('--stream-node requires --stream.');
         }
-        if (args.streamNode != null) {
-            if (args.stream == null) {
-                throw new Error('--stream-node requires --stream.');
-            }
-            console.log(`Streaming node ${chalk.bold(args.streamNode)}`);
+        console.log(`Streaming node ${chalk.bold(args.streamNode)}`);
+    }
+    const app = new Hono();
+    app.use('*', createHttpMiddleware(args));
+    app.get('/healthz', (c) => c.json({
+        ok: true,
+        projectPath: runtime.projectPath,
+    }));
+    app.post('/', async (c) => handleGraphRequest(c, args, runtime, args.graph));
+    app.post('/endpoints/:endpointName', async (c) => {
+        const endpointName = c.req.param('endpointName');
+        const graph = endpointAliases.get(endpointName);
+        if (!graph) {
+            return jsonErrorResponse(c, new CliHttpError(`Endpoint "${endpointName}" not found.`, 404), Date.now(), 404);
         }
-        app.post('/', async (c) => {
-            const project = args.dev ? await loadProjectFromFile(projectFilePath) : initialProject;
-            const inputs = parseJsonInputRecord(await c.req.text(), 'Request body');
-            const graphRunArgs = buildGraphRunArgs(args, project, inputs, args.graph);
-            if (args.stream != null) {
-                const stream = await streamGraph({
-                    ...graphRunArgs,
-                    stream: args.stream,
-                    streamNode: args.streamNode,
-                });
-                return new Response(stream, {
-                    headers: {
-                        'Content-Type': 'text/event-stream',
-                        'Cache-Control': 'no-cache',
-                        Connection: 'keep-alive',
-                    },
-                });
-            }
-            return c.json(await runGraph(graphRunArgs));
-        });
-        if (args.allowSpecifyingGraphId) {
-            app.post('/:graphId', async (c) => {
-                const project = args.dev ? await loadProjectFromFile(projectFilePath) : initialProject;
-                const graph = c.req.param('graphId');
-                throwIfInvalidGraph(project, graph);
-                const inputs = parseJsonInputRecord(await c.req.text(), 'Request body');
-                return c.json(await runGraph(buildGraphRunArgs(args, project, inputs, graph)));
+        return handleGraphRequest(c, args, runtime, graph);
+    });
+    if (args.allowSpecifyingGraphId) {
+        app.post('/:graphId', async (c) => handleGraphRequest(c, args, runtime, c.req.param('graphId')));
+    }
+    return {
+        app,
+        projectFilePath: runtime.projectPath,
+        servedGraphName: resolveServedGraphName(runtime.project, args.graph),
+    };
+}
+async function handleGraphRequest(c, args, runtime, graph) {
+    const startedAt = Date.now();
+    let graphRunArgs;
+    try {
+        const project = args.dev ? await loadProjectFromFile(runtime.projectPath) : runtime.project;
+        throwIfInvalidGraph(project, graph);
+        const inputs = parseJsonInputRecord(await c.req.text(), 'Request body');
+        graphRunArgs = buildGraphRunArgs(args, runtime, project, inputs, graph);
+    }
+    catch (error) {
+        return jsonErrorResponse(c, toBadRequestError(error), startedAt, 400);
+    }
+    try {
+        if (args.stream != null) {
+            const stream = await streamGraph({
+                ...graphRunArgs,
+                stream: args.stream,
+                streamNode: args.streamNode,
             });
-        }
-        const server = serveHono({
-            port: args.port,
-            fetch: app.fetch,
-        });
-        const servedGraphName = resolveServedGraphName(initialProject, args.graph);
-        console.log(chalk.green(`Serving project file ${chalk.bold.white(projectFilePath)} on port ${chalk.bold.white(args.port)}.\nServing graph "${chalk.bold.white(servedGraphName)}".`));
-        function shutdown() {
-            console.log('Shutting down...');
-            server.close((err) => {
-                if (err) {
-                    console.error(err);
-                    process.exit(1);
-                }
-                process.exit(0);
+            return new Response(stream, {
+                headers: {
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                    'Content-Type': 'text/event-stream',
+                },
             });
         }
-        process.on('SIGINT', shutdown);
-        process.on('SIGTERM', shutdown);
+        return jsonTimedResponse(c, await runGraph(graphRunArgs), startedAt);
     }
-    catch (err) {
-        console.error(chalk.red(err));
-        process.exit(1);
+    catch (error) {
+        return jsonErrorResponse(c, error, startedAt, 500);
     }
 }
-function buildGraphRunArgs(args, project, inputs, graph) {
+function buildGraphRunArgs(args, runtime, project, inputs, graph) {
     return {
         exposeCost: args.exposeCost,
         graph,
         inputs,
-        openaiApiKey: args.openaiApiKey,
-        openaiEndpoint: args.openaiEndpoint,
-        openaiOrganization: args.openaiOrganization,
         project,
+        providerOptions: args,
+        runtime,
+        unwrapOutput: args.unwrapOutput,
     };
 }
-async function streamGraph({ project, inputs, graph, openaiApiKey, openaiEndpoint, openaiOrganization, stream, streamNode, }) {
-    const { run, processor, getSSEStream } = createProcessor(project, {
-        inputs,
-        graph,
-        openAiKey: openaiApiKey,
-        openAiEndpoint: openaiEndpoint,
-        openAiOrganization: openaiOrganization,
-    });
+async function streamGraph({ project, inputs, graph, providerOptions, runtime, stream, streamNode, }) {
+    const { run, processor, getSSEStream } = createProcessor(project, withCliProcessorOptions(runtime, providerOptions, buildStreamingGraphProcessorOptions({ graph, inputs })));
     const responseStream = streamNode
         ? getSingleNodeStream(processor, streamNode)
         : getSSEStream(buildStreamEventFilter(stream));
@@ -162,127 +164,66 @@ async function streamGraph({ project, inputs, graph, openaiApiKey, openaiEndpoin
     });
     return responseStream;
 }
+export function buildGraphProcessorOptions({ inputs, graph, openaiApiKey, openaiEndpoint, openaiOrganization, }) {
+    return withProviderProcessorOptions({ openaiApiKey, openaiEndpoint, openaiOrganization }, {
+        graph,
+        inputs,
+    });
+}
+export function buildStreamingGraphProcessorOptions(args) {
+    return {
+        ...buildGraphProcessorOptions(args),
+        runtimeProfile: 'compatible',
+    };
+}
 export function buildStreamEventFilter(stream) {
     const streamTarget = stream?.trim();
     if (!streamTarget) {
         return {
-            nodeStart: true,
             nodeFinish: true,
+            nodeStart: true,
             partialOutputs: true,
         };
     }
     return {
-        nodeStart: [streamTarget],
         nodeFinish: [streamTarget],
+        nodeStart: [streamTarget],
         partialOutputs: [streamTarget],
     };
 }
-async function runGraph({ project, inputs, graph, openaiApiKey, openaiEndpoint, openaiOrganization, exposeCost, }) {
-    const { run } = createProcessor(project, {
-        inputs,
-        graph,
-        openAiKey: openaiApiKey,
-        openAiEndpoint: openaiEndpoint,
-        openAiOrganization: openaiOrganization,
+async function runGraph({ project, inputs, graph, providerOptions, exposeCost, runtime, unwrapOutput, }) {
+    const { run } = createProcessor(project, withCliProcessorOptions(runtime, providerOptions, { graph, inputs }));
+    return shapeOutputs(await run(), {
+        includeCost: exposeCost,
+        unwrapOutput,
     });
-    const outputs = await run();
-    if (!exposeCost) {
-        delete outputs.cost;
-    }
-    return outputs;
-}
-function getGraphSummaries(project) {
-    return Object.values(project.graphs).map((graph) => ({
-        id: graph.metadata.id,
-        name: graph.metadata.name,
-    }));
-}
-function findGraph(project, graphIdOrName) {
-    if (!graphIdOrName) {
-        return undefined;
-    }
-    return getGraphSummaries(project).find((graph) => graph.id === graphIdOrName || graph.name === graphIdOrName);
-}
-function formatGraphList(project) {
-    return getGraphSummaries(project)
-        .map((graph) => `- "${graph.name}" (${graph.id})`)
-        .join('\n');
-}
-function resolveServedGraphName(project, graph) {
-    const servedGraph = findGraph(project, graph ?? project.metadata.mainGraphId);
-    if (!servedGraph) {
-        throw new Error(`Project main graph "${project.metadata.mainGraphId}" was not found in the project file.`);
-    }
-    return servedGraph.name;
 }
-function throwIfNoMainGraph(project, graph, projectFilePath) {
-    if (project.metadata.mainGraphId || graph) {
-        return;
-    }
-    const validGraphs = getGraphSummaries(project);
-    if (validGraphs.length === 0) {
-        throw new Error('No graphs found in the project file. Please edit the project file in Rivet and add a graph.');
-    }
-    const firstExample = `rivet serve ${projectFilePath} --graph ${validGraphs[0].id}`;
-    const secondExample = `rivet serve ${projectFilePath} --graph "${validGraphs[0].name}"`;
-    throw new Error(`No graph name provided, and project does not specify a main graph. Valid graphs are: \n\n${formatGraphList(project)}\n\nUse either the graph's name or its ID. For example, \n- \`${chalk.bold(firstExample)}\` or\n- \`${chalk.bold(secondExample)}\``);
-}
-function throwIfInvalidGraph(project, graph) {
-    if (!graph) {
-        const mainGraphId = project.metadata.mainGraphId;
-        if (!mainGraphId || findGraph(project, mainGraphId)) {
-            return;
+export function parseEndpointAliases(endpointSpecs, project) {
+    const aliases = new Map();
+    for (const spec of endpointSpecs) {
+        const separatorIndex = spec.indexOf('=');
+        if (separatorIndex <= 0) {
+            throw new Error(`Invalid endpoint "${spec}". Expected endpointName=graphNameOrId.`);
         }
-        throw new Error(`Project main graph "${mainGraphId}" was not found in the project file.`);
-    }
-    if (findGraph(project, graph)) {
-        return;
-    }
-    const validGraphsAndIds = getGraphSummaries(project).flatMap((graph) => [graph.id, graph.name]);
-    const suggestion = didYouMean(graph, validGraphsAndIds);
-    if (suggestion) {
-        throw new Error(`Graph "${graph}" not found in project file. Did you mean \`${chalk.bold(`--graph "${suggestion}"`)}\`?`);
-    }
-    throw new Error(`Graph "${graph}" not found in project file. Valid graphs are: \n${formatGraphList(project)}`);
-}
-async function getProjectFile(initialProjectFilePath) {
-    let projectFilePath = resolve(process.cwd(), initialProjectFilePath ?? (await getProjectFilePathFromDirectory(process.cwd())));
-    await throwIfMissingFile(projectFilePath);
-    if ((await stat(projectFilePath)).isDirectory()) {
-        projectFilePath = await getProjectFilePathFromDirectory(projectFilePath);
-    }
-    return projectFilePath;
-}
-async function getProjectFilePathFromDirectory(directory) {
-    const files = await readdir(directory);
-    const projectFiles = files.filter((file) => extname(file).toLowerCase() === '.rivet-project');
-    if (projectFiles.length === 0) {
-        throw new Error('No project file found in the current directory. Project files should end with .rivet-project.');
-    }
-    if (projectFiles.length > 1) {
-        throw new Error(`Multiple project files found in the current directory. Please specify which one to serve: \n${projectFiles.join('\n')}`);
-    }
-    return join(directory, projectFiles[0]);
-}
-async function throwIfMissingFile(filePath) {
-    try {
-        await stat(filePath);
-    }
-    catch (err) {
-        if (err.code !== 'ENOENT') {
-            throw err;
-        }
-        let possibleFiles = [];
-        try {
-            possibleFiles = await readdir(dirname(filePath));
+        const endpointName = spec.slice(0, separatorIndex).trim();
+        const graph = spec.slice(separatorIndex + 1).trim();
+        if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(endpointName)) {
+            throw new Error(`Invalid endpoint name "${endpointName}". Endpoint names must use letters, numbers, hyphens, or underscores, and must start with a letter or number.`);
         }
-        catch {
-            throw new Error(`Could not find project file "${filePath}".`);
+        if (!graph) {
+            throw new Error(`Invalid endpoint "${spec}". Expected a graph name or ID after "=".`);
         }
-        const suggestion = didYouMean(basename(filePath), possibleFiles);
-        if (suggestion) {
-            throw new Error(`Could not find project file "${filePath}". Did you mean "${join(dirname(filePath), suggestion)}"?`);
+        if (aliases.has(endpointName)) {
+            throw new Error(`Duplicate endpoint "${endpointName}".`);
         }
-        throw new Error(`Could not find project file "${filePath}".`);
+        throwIfInvalidGraph(project, graph);
+        aliases.set(endpointName, graph);
+    }
+    return aliases;
+}
+function toBadRequestError(error) {
+    if (error instanceof CliHttpError) {
+        return error;
     }
+    return new CliHttpError(error instanceof Error ? error.message : String(error), 400);
 }

package/bin/commands/serveApp.js

@@ -0,0 +1,99 @@
+import { createRivetWebAppHandler } from '@valerypopoff/rivet2-node';
+import chalk from 'chalk';
+import { configDotenv } from 'dotenv';
+import { Hono } from 'hono';
+import { addDatasetOptions, addProviderOptions, loadProjectRuntime, resolveUiGraph, warnIfServerSavesDatasets, withCliProcessorOptions, } from '../cliRuntime.js';
+import { addHttpOptions, createHttpMiddleware, formatListenUrl, jsonErrorResponse, startHttpServer, } from '../http.js';
+export function makeCommand(y) {
+    const command = addHttpOptions(addProviderOptions(y)
+        .positional('projectFile', {
+        describe: 'The project file containing the Rivet web app',
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('uiGraph', {
+        describe: 'The web app name or ID to serve. If omitted, the only web app in the project is used.',
+        type: 'string',
+    })
+        .option('port', {
+        describe: 'The port to serve on',
+        type: 'number',
+        default: 3000,
+    })
+        .option('host', {
+        describe: 'The host interface to bind to',
+        type: 'string',
+        default: '0.0.0.0',
+    })
+        .option('base-path', {
+        describe: 'The URL base path where the web app is mounted',
+        type: 'string',
+        default: '/',
+    })
+        .option('dev', {
+        describe: 'Run in development mode: rereads the project file on each request',
+        type: 'boolean',
+        default: false,
+    })
+        .option('revision-key', {
+        describe: 'Opaque revision key embedded in HTML and checked on action requests',
+        type: 'string',
+    }));
+    return addDatasetOptions(command);
+}
+export async function serveApp(args) {
+    configDotenv();
+    const { app, projectFilePath, uiGraphName } = await createWebAppServeApp(args);
+    startHttpServer(app, args.host, args.port);
+    console.log(chalk.green(`Serving Rivet web app "${chalk.bold.white(uiGraphName)}" from ${chalk.bold.white(projectFilePath)} at ${chalk.bold.white(formatListenUrl(args.host, args.port))}.`));
+}
+export async function createWebAppServeApp(args) {
+    throwIfReservedBasePath(args.basePath);
+    const runtime = await loadProjectRuntime(args.projectFile, args);
+    const uiGraph = resolveUiGraph(runtime.project, args.uiGraph);
+    const staticHandler = args.dev ? undefined : createHandler(runtime, args, uiGraph.id);
+    warnIfWebAppBearerTokenIsConfigured(args);
+    warnIfServerSavesDatasets(args.saveDatasets, 'CLI web-app server');
+    const app = new Hono();
+    app.use('*', createHttpMiddleware(args));
+    app.get('/healthz', (c) => c.json({
+        ok: true,
+        projectPath: runtime.projectPath,
+        uiGraphId: uiGraph.id,
+    }));
+    app.all('*', async (c) => {
+        const startedAt = Date.now();
+        try {
+            const handler = staticHandler ?? createHandler(await loadProjectRuntime(args.projectFile, args), args, uiGraph.id);
+            return handler.handleRequest(c.req.raw);
+        }
+        catch (error) {
+            return jsonErrorResponse(c, error, startedAt, 500);
+        }
+    });
+    return {
+        app,
+        projectFilePath: runtime.projectPath,
+        uiGraphName: uiGraph.name,
+    };
+}
+function createHandler(runtime, args, uiGraphId = resolveUiGraph(runtime.project, args.uiGraph).id) {
+    return createRivetWebAppHandler(runtime.project, {
+        basePath: args.basePath,
+        createProcessorOptions: () => withCliProcessorOptions(runtime, args, {}),
+        revisionKey: args.revisionKey,
+        uiGraphId,
+    });
+}
+function throwIfReservedBasePath(basePath) {
+    const normalizedBasePath = `/${basePath}`.replace(/\/+/g, '/').replace(/\/$/, '');
+    if (normalizedBasePath === '/healthz') {
+        throw new Error('--base-path /healthz is reserved for the CLI health endpoint.');
+    }
+}
+function warnIfWebAppBearerTokenIsConfigured(args) {
+    if (!args.bearerToken && !process.env.RIVET_CLI_BEARER_TOKEN) {
+        return;
+    }
+    console.warn(chalk.yellow('serve-app bearer-token auth expects clients to send Authorization headers. Browser navigation to the app HTML cannot add that header by itself; use a reverse proxy or cookie auth for browser-facing deployments.'));
+}