@valerypopoff/rivet2-cli 2.0.0 → 2.0.2

package/bin/commandInputs.js

@@ -0,0 +1,33 @@
+function isInputRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function parseJsonInputRecord(text, source) {
+    const trimmedText = text.trim();
+    if (!trimmedText) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmedText);
+    }
+    catch (error) {
+        throw new Error(`${source} must be valid JSON.`, { cause: error });
+    }
+    if (!isInputRecord(parsed)) {
+        throw new Error(`${source} must be a JSON object.`);
+    }
+    return parsed;
+}
+export function parseKeyValueInputRecord(values, source) {
+    return Object.fromEntries(values.map((item) => {
+        const separatorIndex = item.indexOf('=');
+        if (separatorIndex <= 0) {
+            throw new Error(`Invalid ${source} value "${item}". Expected key=value.`);
+        }
+        const key = item.slice(0, separatorIndex).trim();
+        if (!key) {
+            throw new Error(`Invalid ${source} value "${item}". Expected a non-empty key.`);
+        }
+        return [key, item.slice(separatorIndex + 1)];
+    }));
+}

package/bin/commands/run.js

@@ -1,5 +1,6 @@
 import { createProcessor, loadProjectFromFile } from '@valerypopoff/rivet2-node';
 import { resolve } from 'node:path';
+import { parseJsonInputRecord, parseKeyValueInputRecord } from '../commandInputs.js';
 export function makeCommand(y) {
     return y
         .positional('projectFile', {
@@ -40,46 +41,24 @@ export async function run(args) {
         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\n Use 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\``);
+            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 = {};
+        let inputs;
         if (args.inputsStdin) {
-            // Read json from stdin
             const stdin = process.stdin;
             stdin.setEncoding('utf8');
-            let input = '';
+            let inputText = '';
             for await (const chunk of stdin) {
-                input += chunk;
-            }
-            try {
-                inputs = JSON.parse(input);
-            }
-            catch (err) {
-                console.error('Failed to parse input JSON');
-                console.error(err);
-                process.exit(1);
+                inputText += chunk;
             }
+            inputs = parseJsonInputRecord(inputText, 'Input stdin');
         }
         else {
-            inputs = Object.fromEntries(args.input.map((input) => {
-                const [key, value] = input.split('=');
-                if (!key || !value) {
-                    console.error(`Invalid input value: ${input}`);
-                    process.exit(1);
-                }
-                return [key, value];
-            }));
+            inputs = parseKeyValueInputRecord(args.input, 'input');
         }
-        const contextValues = Object.fromEntries(args.context.map((context) => {
-            const [key, value] = context.split('=');
-            if (!key || !value) {
-                console.error(`Invalid context value: ${context}`);
-                process.exit(1);
-            }
-            return [key, value];
-        }));
+        const contextValues = parseKeyValueInputRecord(args.context, 'context');
         const { run } = createProcessor(project, {
             graph: args.graphName,
             inputs,

package/bin/commands/serve.js

@@ -1,11 +1,12 @@
-import { Hono } from 'hono';
 import { serve as serveHono } from '@hono/node-server';
-import { readdir, stat } from 'node:fs/promises';
-import { extname, isAbsolute, join } from 'node:path';
-import didYouMean from 'didyoumean2';
-import { createProcessor, loadProjectFromFile, getSingleNodeStream, } from '@valerypopoff/rivet2-node';
+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';
 export function makeCommand(y) {
     return y
         .option('port', {
@@ -76,20 +77,21 @@ export async function serve(args) {
             console.log('Streaming is enabled');
         }
         if (args.streamNode != null) {
+            if (args.stream == null) {
+                throw new Error('--stream-node requires --stream.');
+            }
             console.log(`Streaming node ${chalk.bold(args.streamNode)}`);
         }
         app.post('/', async (c) => {
             const project = args.dev ? await loadProjectFromFile(projectFilePath) : initialProject;
-            const text = await c.req.text();
-            let inputs = {};
-            if (text.trim()) {
-                inputs = JSON.parse(text);
-                if (typeof inputs !== 'object') {
-                    throw new Error('Inputs must be an object');
-                }
-            }
+            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({ project, inputs, graphId: args.graph, ...args });
+                const stream = await streamGraph({
+                    ...graphRunArgs,
+                    stream: args.stream,
+                    streamNode: args.streamNode,
+                });
                 return new Response(stream, {
                     headers: {
                         'Content-Type': 'text/event-stream',
@@ -98,34 +100,23 @@ export async function serve(args) {
                     },
                 });
             }
-            else {
-                const outputs = await runGraph({ project, inputs, graphId: args.graph, ...args });
-                return c.json(outputs);
-            }
+            return c.json(await runGraph(graphRunArgs));
         });
         if (args.allowSpecifyingGraphId) {
             app.post('/:graphId', async (c) => {
                 const project = args.dev ? await loadProjectFromFile(projectFilePath) : initialProject;
-                const inputs = await c.req.json();
-                const graphId = c.req.param('graphId');
-                const outputs = await runGraph({ project, inputs, graphId, ...args });
-                return c.json(outputs);
+                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)));
             });
         }
         const server = serveHono({
             port: args.port,
             fetch: app.fetch,
         });
-        let servedGraphName;
-        if (args.graph) {
-            const graph = Object.values(initialProject.graphs).find((g) => g.metadata.id === args.graph || g.metadata.name === args.graph);
-            servedGraphName = graph.metadata.name;
-        }
-        else {
-            const graph = Object.values(initialProject.graphs).find((g) => g.metadata.id === initialProject.metadata.mainGraphId);
-            servedGraphName = graph.metadata.name;
-        }
-        console.log(`${chalk.green(`Serving project file ${chalk.bold.white(projectFilePath)} on port ${chalk.bold.white(args.port)}.\nServing graph "${chalk.bold.white(servedGraphName)}".`)}`);
+        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) => {
@@ -144,37 +135,52 @@ export async function serve(args) {
         process.exit(1);
     }
 }
-async function streamGraph({ project, inputs, graphId, openaiApiKey, openaiEndpoint, openaiOrganization, streamNode, }) {
+function buildGraphRunArgs(args, project, inputs, graph) {
+    return {
+        exposeCost: args.exposeCost,
+        graph,
+        inputs,
+        openaiApiKey: args.openaiApiKey,
+        openaiEndpoint: args.openaiEndpoint,
+        openaiOrganization: args.openaiOrganization,
+        project,
+    };
+}
+async function streamGraph({ project, inputs, graph, openaiApiKey, openaiEndpoint, openaiOrganization, stream, streamNode, }) {
     const { run, processor, getSSEStream } = createProcessor(project, {
         inputs,
-        graph: graphId,
+        graph,
         openAiKey: openaiApiKey,
         openAiEndpoint: openaiEndpoint,
         openAiOrganization: openaiOrganization,
     });
-    if (streamNode) {
-        const stream = getSingleNodeStream(processor, streamNode);
-        run().catch((err) => {
-            console.error(err);
-        });
-        return stream;
-    }
-    else {
-        const stream = getSSEStream({
-            nodeStart: streamNode ? [streamNode] : true,
-            nodeFinish: streamNode ? [streamNode] : true,
-            partialOutputs: streamNode ? [streamNode] : true,
-        });
-        run().catch((err) => {
-            console.error(err);
-        });
-        return stream;
+    const responseStream = streamNode
+        ? getSingleNodeStream(processor, streamNode)
+        : getSSEStream(buildStreamEventFilter(stream));
+    run().catch((err) => {
+        console.error(err);
+    });
+    return responseStream;
+}
+export function buildStreamEventFilter(stream) {
+    const streamTarget = stream?.trim();
+    if (!streamTarget) {
+        return {
+            nodeStart: true,
+            nodeFinish: true,
+            partialOutputs: true,
+        };
     }
+    return {
+        nodeStart: [streamTarget],
+        nodeFinish: [streamTarget],
+        partialOutputs: [streamTarget],
+    };
 }
-async function runGraph({ project, inputs, graphId, openaiApiKey, openaiEndpoint, openaiOrganization, exposeCost, }) {
+async function runGraph({ project, inputs, graph, openaiApiKey, openaiEndpoint, openaiOrganization, exposeCost, }) {
     const { run } = createProcessor(project, {
         inputs,
-        graph: graphId,
+        graph,
         openAiKey: openaiApiKey,
         openAiEndpoint: openaiEndpoint,
         openAiOrganization: openaiOrganization,
@@ -185,42 +191,62 @@ async function runGraph({ project, inputs, graphId, openaiApiKey, openaiEndpoint
     }
     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) {
-        const validGraphs = Object.values(project.graphs).map((graph) => [graph.metadata.id, graph.metadata.name]);
-        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 validGraphNames = validGraphs.map(([id, name]) => `• "${name}" (${id})`);
-        const firstExample = `rivet serve ${projectFilePath} --graph ${validGraphs[0][0]}`;
-        const secondExample = `rivet serve ${projectFilePath} --graph "${validGraphs[0][1]}"`;
-        throw new Error(`No graph name provided, and project does not specify a main graph. Valid graphs are: \n\n${validGraphNames.join('\n')}\n\n Use either the graph's name or its ID. For example, \n• \`${chalk.bold(firstExample)}\` or\n• \`${chalk.bold(secondExample)}\``);
+    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 (project.metadata.mainGraphId && !graph) {
+    if (!graph) {
+        const mainGraphId = project.metadata.mainGraphId;
+        if (!mainGraphId || findGraph(project, mainGraphId)) {
+            return;
+        }
+        throw new Error(`Project main graph "${mainGraphId}" was not found in the project file.`);
+    }
+    if (findGraph(project, graph)) {
         return;
     }
-    const matchingGraph = Object.values(project.graphs).find((g) => g.metadata.id === graph || g.metadata.name === graph);
-    if (!matchingGraph) {
-        const validGraphsAndIds = Object.values(project.graphs).flatMap((graph) => [
-            graph.metadata.id,
-            graph.metadata.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}"`)}\`?`);
-        }
-        else {
-            const validGraphsAndIds = Object.values(project.graphs)
-                .map((graph) => `• "${graph.metadata.name}" (${graph.metadata.id})`)
-                .join('\n');
-            throw new Error(`Graph "${graph}" not found in project file. Valid graphs are: \n${validGraphsAndIds}`);
-        }
+    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 = initialProjectFilePath ?? (await getProjectFilePathFromDirectory(process.cwd()));
+    let projectFilePath = resolve(process.cwd(), initialProjectFilePath ?? (await getProjectFilePathFromDirectory(process.cwd())));
     await throwIfMissingFile(projectFilePath);
     if ((await stat(projectFilePath)).isDirectory()) {
         projectFilePath = await getProjectFilePathFromDirectory(projectFilePath);
@@ -229,7 +255,7 @@ async function getProjectFile(initialProjectFilePath) {
 }
 async function getProjectFilePathFromDirectory(directory) {
     const files = await readdir(directory);
-    const projectFiles = files.filter((file) => extname(file) === '.rivet-project');
+    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.');
     }
@@ -246,26 +272,17 @@ async function throwIfMissingFile(filePath) {
         if (err.code !== 'ENOENT') {
             throw err;
         }
-        if (isAbsolute(filePath)) {
-            const parentDir = filePath.split('/').slice(0, -1).join('/');
-            const possibleFiles = await readdir(parentDir);
-            const suggestion = didYouMean(filePath, possibleFiles);
-            if (suggestion) {
-                throw new Error(`Could not find project file "${filePath}". Did you mean "${suggestion}"?`);
-            }
-            else {
-                throw new Error(`Could not find project file "${filePath}".`);
-            }
+        let possibleFiles = [];
+        try {
+            possibleFiles = await readdir(dirname(filePath));
         }
-        else {
-            const possibleFiles = await readdir(process.cwd());
-            const suggestion = didYouMean(filePath, possibleFiles);
-            if (suggestion) {
-                throw new Error(`Could not find project file "${filePath}". Did you mean "${suggestion}"?`);
-            }
-            else {
-                throw new Error(`Could not find project file "${filePath}".`);
-            }
+        catch {
+            throw new Error(`Could not find project file "${filePath}".`);
+        }
+        const suggestion = didYouMean(basename(filePath), possibleFiles);
+        if (suggestion) {
+            throw new Error(`Could not find project file "${filePath}". Did you mean "${join(dirname(filePath), suggestion)}"?`);
         }
+        throw new Error(`Could not find project file "${filePath}".`);
     }
 }

package/dist/types/commandInputs.d.ts

@@ -0,0 +1,3 @@
+import type { LooseDataValue } from '@valerypopoff/rivet2-node';
+export declare function parseJsonInputRecord(text: string, source: string): Record<string, LooseDataValue>;
+export declare function parseKeyValueInputRecord(values: string[], source: string): Record<string, LooseDataValue>;

package/dist/types/commands/run.d.ts

@@ -8,9 +8,9 @@ export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
 } & {
     "include-cost": boolean;
 } & {
-    context: never[] | string[];
+    context: string[] | never[];
 } & {
-    input: never[] | string[];
+    input: string[] | never[];
 }>;
 export declare function run(args: {
     projectFile: string;

package/dist/types/commands/serve.d.ts

@@ -1,4 +1,18 @@
+import type { RivetEventStreamFilterSpec } from '@valerypopoff/rivet2-node';
 import type * as yargs from 'yargs';
+type ServeArgs = {
+    port: number;
+    projectFile: string | undefined;
+    dev: boolean;
+    graph: string | undefined;
+    allowSpecifyingGraphId: boolean;
+    openaiApiKey: string | undefined;
+    openaiEndpoint: string | undefined;
+    openaiOrganization: string | undefined;
+    exposeCost: boolean;
+    stream: string | undefined;
+    streamNode: string | undefined;
+};
 export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
     port: number;
 } & {
@@ -22,16 +36,6 @@ export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
 } & {
     projectFile: string | undefined;
 }>;
-export declare function serve(args: {
-    port: number;
-    projectFile: string | undefined;
-    dev: boolean;
-    graph: string | undefined;
-    allowSpecifyingGraphId: boolean;
-    openaiApiKey: string | undefined;
-    openaiEndpoint: string | undefined;
-    openaiOrganization: string | undefined;
-    exposeCost: boolean;
-    stream: string | undefined;
-    streamNode: string | undefined;
-}): Promise<void>;
+export declare function serve(args: ServeArgs): Promise<void>;
+export declare function buildStreamEventFilter(stream: string | undefined): RivetEventStreamFilterSpec;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valerypopoff/rivet2-cli",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "license": "MIT",
   "types": "dist/types/cli.d.ts",
   "type": "module",
@@ -24,7 +24,7 @@
   "dependencies": {
     "@hono/node-server": "^1.13.8",
     "@types/dotenv": "^8.2.3",
-    "@valerypopoff/rivet2-node": "^2.0.0",
+    "@valerypopoff/rivet2-node": "^2.0.2",
     "chalk": "^5.4.1",
     "didyoumean2": "^7.0.4",
     "dotenv": "^16.4.7",