@valerypopoff/rivet2-cli 2.0.11 → 2.1.0

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.'));
+}

package/bin/http.js

@@ -0,0 +1,107 @@
+import { serve as serveHono } from '@hono/node-server';
+export class CliHttpError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.status = status;
+        this.name = 'CliHttpError';
+    }
+}
+export function addHttpOptions(y) {
+    return y
+        .option('bearer-token', {
+        describe: 'Require Authorization: Bearer <token>. Defaults to RIVET_CLI_BEARER_TOKEN.',
+        type: 'string',
+    })
+        .option('cors-origin', {
+        describe: 'Allow a CORS origin. Can be repeated, or set to *.',
+        type: 'string',
+        array: true,
+        default: [],
+    });
+}
+export function createHttpMiddleware({ bearerToken, corsOrigin = [] }) {
+    const effectiveBearerToken = bearerToken ?? process.env.RIVET_CLI_BEARER_TOKEN;
+    return async (c, next) => {
+        applyCorsHeaders(c, corsOrigin);
+        if (c.req.method === 'OPTIONS' && corsOrigin.length > 0) {
+            return c.body(null, 204);
+        }
+        if (c.req.path !== '/healthz' && effectiveBearerToken) {
+            const authorization = c.req.header('authorization');
+            if (authorization !== `Bearer ${effectiveBearerToken}`) {
+                return c.json({
+                    error: {
+                        message: 'Unauthorized.',
+                        name: 'Unauthorized',
+                    },
+                    durationMs: 0,
+                }, 401);
+            }
+        }
+        await next();
+        applyCorsHeaders(c, corsOrigin);
+    };
+}
+export function jsonErrorResponse(c, error, startedAt, fallbackStatus = 500) {
+    const status = error instanceof CliHttpError ? error.status : fallbackStatus;
+    const durationMs = Math.max(0, Date.now() - startedAt);
+    c.header('x-duration-ms', String(durationMs));
+    return c.json({
+        error: {
+            message: error instanceof Error ? error.message : String(error),
+            name: error instanceof Error ? error.name : 'Error',
+        },
+        durationMs,
+    }, toCliJsonStatus(status));
+}
+export function jsonTimedResponse(c, payload, startedAt) {
+    c.header('x-duration-ms', String(Math.max(0, Date.now() - startedAt)));
+    return c.json(payload);
+}
+export function formatListenUrl(host, port) {
+    const displayHost = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+    return `http://${displayHost}:${port}`;
+}
+export function startHttpServer(app, host, port) {
+    const server = serveHono({
+        fetch: app.fetch,
+        hostname: host,
+        port,
+    });
+    function shutdown() {
+        console.log('Shutting down...');
+        server.close((err) => {
+            if (err) {
+                console.error(err);
+                process.exit(1);
+            }
+            process.exit(0);
+        });
+    }
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+function applyCorsHeaders(c, corsOrigins) {
+    if (corsOrigins.length === 0) {
+        return;
+    }
+    const requestOrigin = c.req.header('origin');
+    const allowedOrigin = resolveAllowedOrigin(corsOrigins, requestOrigin);
+    if (!allowedOrigin) {
+        return;
+    }
+    c.header('access-control-allow-origin', allowedOrigin);
+    c.header('access-control-allow-methods', 'GET,POST,OPTIONS');
+    c.header('access-control-allow-headers', 'content-type,authorization');
+    c.header('vary', 'Origin');
+}
+function resolveAllowedOrigin(corsOrigins, requestOrigin) {
+    if (corsOrigins.includes('*')) {
+        return '*';
+    }
+    return requestOrigin && corsOrigins.includes(requestOrigin) ? requestOrigin : undefined;
+}
+function toCliJsonStatus(status) {
+    return status === 400 || status === 401 || status === 404 || status === 409 || status === 500 ? status : 500;
+}

package/bin/output.js

@@ -0,0 +1,32 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+export function shapeOutputs(outputs, options) {
+    validateOutputShapeOptions(options);
+    const { includeCost = false, outputKey, unwrapOutput } = options;
+    const visibleOutputs = { ...outputs };
+    if (!includeCost) {
+        delete visibleOutputs.cost;
+    }
+    const selectedOutputKey = unwrapOutput ?? outputKey;
+    if (!selectedOutputKey) {
+        return visibleOutputs;
+    }
+    if (!Object.prototype.hasOwnProperty.call(visibleOutputs, selectedOutputKey)) {
+        throw new Error(`Output "${selectedOutputKey}" was not returned by the graph.`);
+    }
+    const selectedOutput = visibleOutputs[selectedOutputKey];
+    return unwrapOutput ? selectedOutput?.value : selectedOutput;
+}
+export function validateOutputShapeOptions({ outputKey, unwrapOutput }) {
+    if (outputKey && unwrapOutput) {
+        throw new Error('Use only one output selector. Received: --output-key, --unwrap-output.');
+    }
+}
+export async function writeJsonOutput(payload, outputFile) {
+    const json = `${JSON.stringify(payload, null, 2)}\n`;
+    if (outputFile) {
+        await writeFile(resolve(process.cwd(), outputFile), json, 'utf8');
+        return;
+    }
+    process.stdout.write(json);
+}

package/dist/types/cliRuntime.d.ts

@@ -0,0 +1,47 @@
+import { NodeDatasetProvider, type NodeCreateProcessorOptions, type Project, type UiGraph } from '@valerypopoff/rivet2-node';
+import type * as yargs from 'yargs';
+export type DatasetCliOptions = {
+    datasetFile?: string;
+    requireDatasetFile?: boolean;
+    saveDatasets?: boolean;
+};
+export type ProviderCliOptions = {
+    openaiApiKey?: string;
+    openaiEndpoint?: string;
+    openaiOrganization?: string;
+};
+export type LoadedProjectRuntime = {
+    datasetProvider: NodeDatasetProvider;
+    project: Project;
+    projectPath: string;
+};
+export type GraphSummary = {
+    id: string;
+    name: string;
+};
+export type UiGraphSummary = {
+    id: string;
+    name: string;
+};
+type GraphArgumentStyle = 'option' | 'positional';
+export declare function loadProjectRuntime(projectFile: string | undefined, datasetOptions: DatasetCliOptions): Promise<LoadedProjectRuntime>;
+export declare function createDatasetProvider(projectPath: string, { datasetFile, requireDatasetFile, saveDatasets }: DatasetCliOptions): Promise<NodeDatasetProvider>;
+export declare function resolveDatasetFilePath(projectPath: string, datasetFile?: string): string;
+export declare function withRuntimeProcessorOptions(runtime: Pick<LoadedProjectRuntime, 'datasetProvider' | 'projectPath'>, options: Omit<NodeCreateProcessorOptions, 'datasetProvider' | 'projectPath'>): NodeCreateProcessorOptions;
+export declare function withCliProcessorOptions(runtime: Pick<LoadedProjectRuntime, 'datasetProvider' | 'projectPath'>, providerOptions: ProviderCliOptions, options: Omit<NodeCreateProcessorOptions, 'datasetProvider' | 'openAiEndpoint' | 'openAiKey' | 'openAiOrganization' | 'projectPath'>): NodeCreateProcessorOptions;
+export declare function withProviderProcessorOptions(providerOptions: ProviderCliOptions, options: Omit<NodeCreateProcessorOptions, 'openAiEndpoint' | 'openAiKey' | 'openAiOrganization'>): NodeCreateProcessorOptions;
+export declare function addProviderOptions<T>(y: yargs.Argv<T>): yargs.Argv<T>;
+export declare function addDatasetOptions<T>(y: yargs.Argv<T>, { includeSaveDatasets }?: {
+    includeSaveDatasets?: boolean;
+}): yargs.Argv<T>;
+export declare function warnIfServerSavesDatasets(saveDatasets: boolean | undefined, label?: string): void;
+export declare function getGraphSummaries(project: Project): GraphSummary[];
+export declare function findGraph(project: Project, graphIdOrName: string | undefined): GraphSummary | undefined;
+export declare function formatGraphList(project: Project): string;
+export declare function resolveServedGraphName(project: Project, graph: string | undefined): string;
+export declare function throwIfNoMainGraph(project: Project, graph: string | undefined, projectFilePath: string, argumentStyle?: GraphArgumentStyle): void;
+export declare function throwIfInvalidGraph(project: Project, graph: string | undefined, argumentStyle?: GraphArgumentStyle): void;
+export declare function getUiGraphSummaries(project: Project): UiGraphSummary[];
+export declare function resolveUiGraph(project: Project, uiGraphIdOrName: string | undefined): UiGraph;
+export declare function getProjectFile(initialProjectFilePath: string | undefined): Promise<string>;
+export {};

package/dist/types/commandInputs.d.ts

@@ -1,3 +1,9 @@
-import type { LooseDataValue } from '@valerypopoff/rivet2-node';
+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>;
+export declare function parseJsonKeyValueInputRecord(values: string[], source: string): Record<string, LooseDataValue>;
+export declare function parseJsonInputRecordFromFile(filePath: string, source: string): Promise<Record<string, LooseDataValue>>;
+export declare function throwIfConflictingInputSources(sources: Array<{
+    enabled: boolean;
+    name: string;
+}>, sourceKind: string): void;

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

@@ -0,0 +1,28 @@
+import type * as yargs from 'yargs';
+import { type DatasetCliOptions } from '../cliRuntime.js';
+export type DoctorArgs = {
+    json: boolean;
+    projectFile: string;
+} & DatasetCliOptions;
+export type DoctorCheckStatus = 'ok' | 'warning' | 'error';
+export type DoctorCheck = {
+    id: string;
+    message: string;
+    status: DoctorCheckStatus;
+};
+export type DoctorReport = {
+    checks: DoctorCheck[];
+    ok: boolean;
+    path: string;
+    summary: {
+        errors: number;
+        warnings: number;
+    };
+};
+export declare function makeDoctorCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
+    projectFile: string;
+} & {
+    json: boolean;
+}>;
+export declare function doctor(args: DoctorArgs): Promise<void>;
+export declare function buildDoctorReport(projectFile: string, options?: DatasetCliOptions): Promise<DoctorReport>;

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

@@ -0,0 +1,44 @@
+import { type Project } from '@valerypopoff/rivet2-node';
+import type * as yargs from 'yargs';
+export type ProjectListArgs = {
+    json: boolean;
+    projectFile: string;
+};
+export declare function makeListCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
+    projectFile: string;
+} & {
+    json: boolean;
+}>;
+export declare function makeInspectCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
+    projectFile: string;
+}>;
+export declare function list(args: ProjectListArgs): Promise<void>;
+export declare function inspect(projectFile: string): Promise<void>;
+export type ProjectInspection = {
+    graphs: Array<{
+        id: string;
+        main: boolean;
+        name: string;
+        nodes: number;
+    }>;
+    libraryNodes: Array<{
+        id: string;
+        nodeType: string;
+        title: string;
+    }>;
+    path: string;
+    plugins: NonNullable<Project['plugins']>;
+    project: {
+        description?: string;
+        id: string;
+        mainGraphId?: string;
+        title: string;
+    };
+    webApps: Array<{
+        components: number;
+        id: string;
+        name: string;
+    }>;
+};
+export declare function inspectProject(projectFile: string): Promise<ProjectInspection>;
+export declare function buildProjectInspection(project: Project, projectPath: string): ProjectInspection;

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

@@ -1,22 +1,46 @@
 import type * as yargs from 'yargs';
+import { type DatasetCliOptions, type ProviderCliOptions } from '../cliRuntime.js';
+type RunArgs = {
+    context: string[];
+    contextFile: string | undefined;
+    contextJson: string[];
+    graphName: string | undefined;
+    includeCost: boolean;
+    input: string[];
+    inputJson: string[];
+    inputsFile: string | undefined;
+    inputsStdin: boolean;
+    outputFile: string | undefined;
+    outputKey: string | undefined;
+    projectFile: string;
+    unwrapOutput: string | undefined;
+} & DatasetCliOptions & ProviderCliOptions;
 export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
     projectFile: string;
 } & {
     graphName: string | undefined;
 } & {
     "inputs-stdin": boolean;
+} & {
+    "inputs-file": string | undefined;
+} & {
+    "input-json": string[] | never[];
 } & {
     "include-cost": boolean;
+} & {
+    "output-key": string | undefined;
+} & {
+    "unwrap-output": string | undefined;
+} & {
+    "output-file": string | undefined;
 } & {
     context: string[] | never[];
+} & {
+    "context-json": string[] | never[];
+} & {
+    "context-file": string | undefined;
 } & {
     input: string[] | never[];
 }>;
-export declare function run(args: {
-    projectFile: string;
-    graphName: string | undefined;
-    inputsStdin: boolean;
-    includeCost: boolean;
-    context: string[];
-    input: string[];
-}): Promise<void>;
+export declare function run(args: RunArgs): Promise<void>;
+export {};

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

@@ -1,30 +1,40 @@
 import type { LooseDataValue, NodeCreateProcessorOptions, Project, RivetEventStreamFilterSpec } from '@valerypopoff/rivet2-node';
+import { Hono } from 'hono';
 import type * as yargs from 'yargs';
-type ServeArgs = {
-    port: number;
-    projectFile: string | undefined;
-    dev: boolean;
-    graph: string | undefined;
+import { type DatasetCliOptions, type LoadedProjectRuntime, type ProviderCliOptions } from '../cliRuntime.js';
+import { type HttpCliOptions } from '../http.js';
+export type ServeArgs = {
     allowSpecifyingGraphId: boolean;
-    openaiApiKey: string | undefined;
-    openaiEndpoint: string | undefined;
-    openaiOrganization: string | undefined;
+    dev: boolean;
+    endpoint: string[];
     exposeCost: boolean;
+    graph: string | undefined;
+    host: string;
+    port: number;
+    projectFile: string | undefined;
     stream: string | undefined;
     streamNode: string | undefined;
-};
+    unwrapOutput: string | undefined;
+} & DatasetCliOptions & ProviderCliOptions & HttpCliOptions;
 type GraphRunArgs = {
     exposeCost: boolean;
     graph: string | undefined;
     inputs: Record<string, LooseDataValue>;
-    openaiApiKey: string | undefined;
-    openaiEndpoint: string | undefined;
-    openaiOrganization: string | undefined;
     project: Project;
+    providerOptions: ProviderCliOptions;
+    runtime: Pick<LoadedProjectRuntime, 'datasetProvider' | 'projectPath'>;
+    unwrapOutput: string | undefined;
+};
+type GraphProcessorArgs = Omit<GraphRunArgs, 'exposeCost' | 'project' | 'providerOptions' | 'runtime' | 'unwrapOutput'> & ProviderCliOptions;
+export type ServeAppInfo = {
+    app: Hono;
+    projectFilePath: string;
+    servedGraphName: string;
 };
-type GraphProcessorArgs = Omit<GraphRunArgs, 'exposeCost' | 'project'>;
 export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
     port: number;
+} & {
+    host: string;
 } & {
     dev: boolean;
 } & {
@@ -32,13 +42,11 @@ export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
 } & {
     "allow-specifying-graph-id": boolean;
 } & {
-    "openai-api-key": string | undefined;
-} & {
-    "openai-endpoint": string | undefined;
-} & {
-    "openai-organization": string | undefined;
+    endpoint: string[] | never[];
 } & {
     "expose-cost": boolean;
+} & {
+    "unwrap-output": string | undefined;
 } & {
     stream: string | undefined;
 } & {
@@ -47,7 +55,9 @@ export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
     projectFile: string | undefined;
 }>;
 export declare function serve(args: ServeArgs): Promise<void>;
+export declare function createServeApp(args: ServeArgs): Promise<ServeAppInfo>;
 export declare function buildGraphProcessorOptions({ inputs, graph, openaiApiKey, openaiEndpoint, openaiOrganization, }: GraphProcessorArgs): NodeCreateProcessorOptions;
 export declare function buildStreamingGraphProcessorOptions(args: GraphProcessorArgs): NodeCreateProcessorOptions;
 export declare function buildStreamEventFilter(stream: string | undefined): RivetEventStreamFilterSpec;
+export declare function parseEndpointAliases(endpointSpecs: string[], project: Project): Map<string, string>;
 export {};

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

@@ -0,0 +1,35 @@
+import { Hono } from 'hono';
+import type * as yargs from 'yargs';
+import { type DatasetCliOptions, type ProviderCliOptions } from '../cliRuntime.js';
+import { type HttpCliOptions } from '../http.js';
+export type ServeAppArgs = {
+    basePath: string;
+    dev: boolean;
+    host: string;
+    port: number;
+    projectFile: string;
+    revisionKey: string | undefined;
+    uiGraph: string | undefined;
+} & DatasetCliOptions & ProviderCliOptions & HttpCliOptions;
+export type WebAppServeInfo = {
+    app: Hono;
+    projectFilePath: string;
+    uiGraphName: string;
+};
+export declare function makeCommand<T>(y: yargs.Argv<T>): yargs.Argv<T & {
+    projectFile: string;
+} & {
+    uiGraph: string | undefined;
+} & {
+    port: number;
+} & {
+    host: string;
+} & {
+    "base-path": string;
+} & {
+    dev: boolean;
+} & {
+    "revision-key": string | undefined;
+}>;
+export declare function serveApp(args: ServeAppArgs): Promise<void>;
+export declare function createWebAppServeApp(args: ServeAppArgs): Promise<WebAppServeInfo>;

package/dist/types/http.d.ts

@@ -0,0 +1,23 @@
+import type { Context, Hono, MiddlewareHandler } from 'hono';
+import type * as yargs from 'yargs';
+export type HttpCliOptions = {
+    bearerToken?: string;
+    corsOrigin?: string[];
+};
+export type HttpJsonError = {
+    error: {
+        message: string;
+        name: string;
+    };
+    durationMs: number;
+};
+export declare class CliHttpError extends Error {
+    readonly status: number;
+    constructor(message: string, status?: number);
+}
+export declare function addHttpOptions<T>(y: yargs.Argv<T>): yargs.Argv<T>;
+export declare function createHttpMiddleware({ bearerToken, corsOrigin }: HttpCliOptions): MiddlewareHandler;
+export declare function jsonErrorResponse(c: Context, error: unknown, startedAt: number, fallbackStatus?: number): Response;
+export declare function jsonTimedResponse(c: Context, payload: unknown, startedAt: number): Response;
+export declare function formatListenUrl(host: string, port: number): string;
+export declare function startHttpServer(app: Hono, host: string, port: number): void;

package/dist/types/output.d.ts

@@ -0,0 +1,9 @@
+import type { Outputs } from '@valerypopoff/rivet2-node';
+export type OutputShapeOptions = {
+    includeCost?: boolean;
+    outputKey?: string;
+    unwrapOutput?: string;
+};
+export declare function shapeOutputs(outputs: Outputs, options: OutputShapeOptions): unknown;
+export declare function validateOutputShapeOptions({ outputKey, unwrapOutput }: OutputShapeOptions): void;
+export declare function writeJsonOutput(payload: unknown, outputFile: string | undefined): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valerypopoff/rivet2-cli",
-  "version": "2.0.11",
+  "version": "2.1.0",
   "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.11",
+    "@valerypopoff/rivet2-node": "^2.1.0",
     "chalk": "^5.4.1",
     "didyoumean2": "^7.0.4",
     "dotenv": "^16.4.7",