@optimizely-opal/opal-tools-sdk 0.1.6-dev → 0.1.9-dev

package/dist/proteus.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Generated by json-schema-to-typescript
+ * DO NOT MODIFY - This file is auto-generated from proteus-document-spec.json
+ * Run 'npm run generate:proteus' to regenerate
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UI = void 0;
+/**
+ * Builder namespace for Adaptive UI Document components.
+ *
+ * Usage:
+ *   UI.Document({ children: [...] })
+ *   UI.Heading({ children: "Title", level: "2" })
+ *   UI.Input({ name: "field_name", placeholder: "Enter..." })
+ */
+exports.UI = {
+    Action: (props) => ({
+        $type: "Action",
+        ...props,
+    }),
+    Badge: (props) => ({
+        $type: "Badge",
+        ...props,
+    }),
+    CancelAction: (props) => ({ $type: "CancelAction", ...props }),
+    Chart: (props) => ({
+        $type: "Chart",
+        ...props,
+    }),
+    DataTable: (props) => ({
+        $type: "DataTable",
+        ...props,
+    }),
+    Document: (props) => ({
+        $type: "Document",
+        ...props,
+    }),
+    Field: (props) => ({
+        $type: "Field",
+        ...props,
+    }),
+    Group: (props) => ({
+        $type: "Group",
+        ...props,
+    }),
+    Heading: (props) => ({
+        $type: "Heading",
+        ...props,
+    }),
+    Image: (props) => ({
+        $type: "Image",
+        ...props,
+    }),
+    Input: (props) => ({
+        $type: "Input",
+        ...props,
+    }),
+    Link: (props) => ({
+        $type: "Link",
+        ...props,
+    }),
+    Map: (props) => ({
+        $type: "Map",
+        ...props,
+    }),
+    MIME_TYPE: "application/vnd.opal.proteus+json",
+    Range: (props) => ({
+        $type: "Range",
+        ...props,
+    }),
+    Select: (props) => ({
+        $type: "Select",
+        ...props,
+    }),
+    SelectContent: (props) => ({ $type: "SelectContent", ...props }),
+    SelectTrigger: (props) => ({ $type: "SelectTrigger", ...props }),
+    Separator: (props) => ({
+        $type: "Separator",
+        ...props,
+    }),
+    Show: (props) => ({
+        $type: "Show",
+        ...props,
+    }),
+    Text: (props) => ({
+        $type: "Text",
+        ...props,
+    }),
+    Textarea: (props) => ({
+        $type: "Textarea",
+        ...props,
+    }),
+    Value: (props) => ({
+        $type: "Value",
+        ...props,
+    }),
+};

package/dist/registerResource.d.ts

@@ -0,0 +1,60 @@
+import { ProteusDocument } from "./proteus";
+type ResourceOptions = {
+    /** Description of the resource */
+    description?: string;
+    /** MIME type of the resource content (e.g., "application/vnd.opal.proteus+json") */
+    mimeType?: string;
+    /** Human-readable title for the resource */
+    title?: string;
+    /** The unique URI for this resource (e.g., "ui://my-app/create-form") */
+    uri: string;
+};
+/**
+ * Register a function as an MCP resource
+ *
+ * The handler can return either a string or a UI.Document. When returning a UI.Document,
+ * the SDK will automatically serialize it to JSON and set the MIME type to
+ * "application/vnd.opal.proteus+json" (if not already specified).
+ *
+ * @example
+ * ```typescript
+ * // Example 1: Returning a string (manual serialization)
+ * const getFormResource = registerResource('create-form', {
+ *   uri: 'ui://my-app/create-form',
+ *   description: 'Create form UI specification',
+ *   mimeType: 'application/vnd.opal.proteus+json',
+ *   title: 'Create Form'
+ * }, async () => {
+ *   return JSON.stringify(proteusSpec);
+ * });
+ *
+ * // Example 2: Returning a UI.Document (automatic serialization)
+ * import { UI } from '@optimizely-opal/opal-tools-sdk';
+ *
+ * const getDynamicForm = registerResource('create-form', {
+ *   uri: 'ui://my-app/create-form',
+ *   description: 'Create form UI specification',
+ *   title: 'Create Form'
+ * }, async () => {
+ *   return UI.Document({
+ *     appName: 'Item Manager',
+ *     title: 'Create New Item',
+ *     body: [
+ *       UI.Heading({ children: 'Create Item' }),
+ *       UI.Field({
+ *         label: 'Name',
+ *         children: UI.Input({ name: 'item_name' })
+ *       })
+ *     ],
+ *     actions: [UI.Action({ children: 'Save' })]
+ *   });
+ * });
+ * ```
+ *
+ * @param name - Name of the resource
+ * @param options - Resource options (uri, description, mimeType, title)
+ * @param handler - Async function that returns the resource content (string or UI.Document)
+ * @returns The handler function (for convenience)
+ */
+export declare function registerResource(name: string, options: ResourceOptions, handler: () => Promise<ProteusDocument | string> | ProteusDocument | string): typeof handler;
+export {};

package/dist/registerResource.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerResource = registerResource;
+const registry_1 = require("./registry");
+/**
+ * Register a function as an MCP resource
+ *
+ * The handler can return either a string or a UI.Document. When returning a UI.Document,
+ * the SDK will automatically serialize it to JSON and set the MIME type to
+ * "application/vnd.opal.proteus+json" (if not already specified).
+ *
+ * @example
+ * ```typescript
+ * // Example 1: Returning a string (manual serialization)
+ * const getFormResource = registerResource('create-form', {
+ *   uri: 'ui://my-app/create-form',
+ *   description: 'Create form UI specification',
+ *   mimeType: 'application/vnd.opal.proteus+json',
+ *   title: 'Create Form'
+ * }, async () => {
+ *   return JSON.stringify(proteusSpec);
+ * });
+ *
+ * // Example 2: Returning a UI.Document (automatic serialization)
+ * import { UI } from '@optimizely-opal/opal-tools-sdk';
+ *
+ * const getDynamicForm = registerResource('create-form', {
+ *   uri: 'ui://my-app/create-form',
+ *   description: 'Create form UI specification',
+ *   title: 'Create Form'
+ * }, async () => {
+ *   return UI.Document({
+ *     appName: 'Item Manager',
+ *     title: 'Create New Item',
+ *     body: [
+ *       UI.Heading({ children: 'Create Item' }),
+ *       UI.Field({
+ *         label: 'Name',
+ *         children: UI.Input({ name: 'item_name' })
+ *       })
+ *     ],
+ *     actions: [UI.Action({ children: 'Save' })]
+ *   });
+ * });
+ * ```
+ *
+ * @param name - Name of the resource
+ * @param options - Resource options (uri, description, mimeType, title)
+ * @param handler - Async function that returns the resource content (string or UI.Document)
+ * @returns The handler function (for convenience)
+ */
+function registerResource(name, options, handler) {
+    console.log(`Registering resource ${name} with URI ${options.uri}`);
+    // Register the resource with all services
+    for (const service of registry_1.registry.services) {
+        service.registerResource(options.uri, name, options.description, options.mimeType, options.title, handler);
+    }
+    return handler;
+}

package/dist/registerTool.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod/v4";
-import type { BlockResponse } from "./block";
 import { Credentials } from "./models";
 /**
  * Extra context passed to tool handlers
@@ -13,7 +12,7 @@ export type RequestHandlerExtra = {
     /** Execution mode: 'headless' for non-interactive, 'interactive' for user interaction (defaults to 'headless') */
     mode: "headless" | "interactive";
 };
-type ToolOptions<TSchema extends Record<string, z.ZodTypeAny>, TType extends "block" | "json" = "json"> = {
+type ToolOptions<TSchema extends Record<string, z.ZodTypeAny>> = {
     authRequirements?: {
         provider: string;
         required?: boolean;
@@ -21,7 +20,7 @@ type ToolOptions<TSchema extends Record<string, z.ZodTypeAny>, TType extends "bl
     };
     description: string;
     inputSchema: TSchema;
-    type?: TType;
+    uiResource?: string;
 };
 /**
  * Register a function as an Opal tool
@@ -58,11 +57,23 @@ type ToolOptions<TSchema extends Record<string, z.ZodTypeAny>, TType extends "bl
  *   return fetch(params.url, { headers });
  * });
  * ```
+ *
+ * @example
+ * ```typescript
+ * // With UI resource for dynamic rendering
+ * const createTaskTool = registerTool('create_task', {
+ *   description: 'Create a new task',
+ *   inputSchema: {
+ *     title: z.string().describe('Task title'),
+ *     description: z.string().describe('Task description')
+ *   },
+ *   uiResource: 'ui://my-app/create-form'
+ * }, async (params) => {
+ *   return { id: 'task-123', ...params };
+ * });
+ * ```
  */
-export declare function registerTool<TSchema extends Record<string, z.ZodTypeAny>>(name: string, options: ToolOptions<TSchema, "block">, handler: (params: {
-    [K in keyof TSchema]: z.infer<TSchema[K]>;
-}, extra?: RequestHandlerExtra) => BlockResponse | Promise<BlockResponse>): typeof handler;
-export declare function registerTool<TSchema extends Record<string, z.ZodTypeAny>>(name: string, options: Omit<ToolOptions<TSchema>, "type"> | ToolOptions<TSchema, "json">, handler: (params: {
+export declare function registerTool<TSchema extends Record<string, z.ZodTypeAny>>(name: string, options: ToolOptions<TSchema>, handler: (params: {
     [K in keyof TSchema]: z.infer<TSchema[K]>;
 }, extra?: RequestHandlerExtra) => Promise<unknown> | unknown): typeof handler;
 export {};

package/dist/registerTool.js

@@ -4,16 +4,65 @@ exports.registerTool = registerTool;
 const v4_1 = require("zod/v4");
 const models_1 = require("./models");
 const registry_1 = require("./registry");
-// Implementation
+/**
+ * Register a function as an Opal tool
+ *
+ * @example
+ * ```typescript
+ * const greetTool = registerTool('greet', {
+ *   description: 'Greet a user',
+ *   inputSchema: {
+ *     name: z.string().describe('The name to greet')
+ *   }
+ * }, async (params) => {
+ *   // params is automatically typed as { name: string }
+ *   return `Hello, ${params.name}!`;
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With auth and execution mode
+ * const fetchTool = registerTool('fetch_data', {
+ *   description: 'Fetch data from API',
+ *   inputSchema: {
+ *     url: z.string().describe('URL to fetch')
+ *   },
+ *   authRequirements: {
+ *     provider: 'api-service',
+ *     scopeBundle: 'read'
+ *   }
+ * }, async (params, extra) => {
+ *   // extra.mode: 'headless' | 'interactive'
+ *   // extra.auth: { provider, credentials }
+ *   const headers = extra?.auth ? { Authorization: extra.auth.credentials.token } : {};
+ *   return fetch(params.url, { headers });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With UI resource for dynamic rendering
+ * const createTaskTool = registerTool('create_task', {
+ *   description: 'Create a new task',
+ *   inputSchema: {
+ *     title: z.string().describe('Task title'),
+ *     description: z.string().describe('Task description')
+ *   },
+ *   uiResource: 'ui://my-app/create-form'
+ * }, async (params) => {
+ *   return { id: 'task-123', ...params };
+ * });
+ * ```
+ */
 function registerTool(name, options, handler) {
     // Register the tool with all services
-    const responseType = options.type || "json";
     for (const service of registry_1.registry.services) {
         service.registerTool(name, options.description, handler, jsonSchemaToParameters(v4_1.z.toJSONSchema(v4_1.z.object(options.inputSchema))), `/tools/${name.replace(/_/g, "-")}`, options.authRequirements
             ? [
                 new models_1.AuthRequirement(options.authRequirements.provider, options.authRequirements.scopeBundle, options.authRequirements.required ?? true),
             ]
-            : undefined, responseType, true);
+            : undefined, true, options.uiResource);
     }
     return handler;
 }

package/dist/service.d.ts

@@ -1,14 +1,26 @@
 import { Express } from "express";
 import { AuthRequirement, Parameter } from "./models";
+import { ProteusDocument } from "./proteus";
 export declare class ToolsService {
     private app;
     private functions;
+    private resources;
     private router;
     /**
      * Initialize a new tools service
      * @param app Express application
      */
     constructor(app: Express);
+    /**
+     * Register a resource function
+     * @param uri The unique URI for this resource (e.g., "ui://my-app/create-form")
+     * @param name Name of the resource
+     * @param description Description of the resource (optional)
+     * @param mimeType MIME type of the resource content (optional)
+     * @param title Human-readable title for the resource (optional)
+     * @param handler Function implementing the resource (returns string or ProteusDocument)
+     */
+    registerResource(uri: string, name: string, description: string | undefined, mimeType: string | undefined, title: string | undefined, handler: () => Promise<ProteusDocument | string> | ProteusDocument | string): void;
     /**
      * Register a tool function
      * @param name Tool name
@@ -17,13 +29,13 @@ export declare class ToolsService {
      * @param parameters List of parameters for the tool
      * @param endpoint API endpoint for the tool
      * @param authRequirements Authentication requirements (optional)
-     * @param responseType Response type - 'json' (default) or 'block'
      * @param isNewStyle Whether this is a new-style tool (registerTool) vs legacy decorator
+     * @param uiResource URI of associated UI resource for dynamic rendering (optional)
      */
     registerTool(name: string, description: string, handler: any, // Changed from Function to any to avoid confusion with built-in Function type
-    parameters: Parameter[], endpoint: string, authRequirements?: AuthRequirement[], responseType?: "block" | "json", isNewStyle?: boolean): void;
+    parameters: Parameter[], endpoint: string, authRequirements?: AuthRequirement[], isNewStyle?: boolean, uiResource?: string): void;
     /**
-     * Initialize the discovery endpoint
+     * Initialize the discovery endpoint and resources/read endpoint
      */
     private initRoutes;
 }

package/dist/service.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolsService = void 0;
 const express_1 = __importDefault(require("express"));
-const block_1 = require("./block");
 const models_1 = require("./models");
+const proteus_1 = require("./proteus");
 const registry_1 = require("./registry");
 class ToolsService {
     /**
@@ -15,12 +15,28 @@ class ToolsService {
      */
     constructor(app) {
         this.functions = [];
+        this.resources = new Map();
         this.app = app;
         this.router = express_1.default.Router();
         this.initRoutes();
         // Register this service in the global registry
         registry_1.registry.services.push(this);
     }
+    /**
+     * Register a resource function
+     * @param uri The unique URI for this resource (e.g., "ui://my-app/create-form")
+     * @param name Name of the resource
+     * @param description Description of the resource (optional)
+     * @param mimeType MIME type of the resource content (optional)
+     * @param title Human-readable title for the resource (optional)
+     * @param handler Function implementing the resource (returns string or ProteusDocument)
+     */
+    registerResource(uri, name, description, mimeType, title, handler) {
+        console.log(`Registering resource: ${name} with URI: ${uri}`);
+        const metadata = new models_1.Resource(uri, name, description, mimeType, title);
+        // Store both metadata and handler together
+        this.resources.set(uri, { handler, metadata });
+    }
     /**
      * Register a tool function
      * @param name Tool name
@@ -29,17 +45,15 @@ class ToolsService {
      * @param parameters List of parameters for the tool
      * @param endpoint API endpoint for the tool
      * @param authRequirements Authentication requirements (optional)
-     * @param responseType Response type - 'json' (default) or 'block'
      * @param isNewStyle Whether this is a new-style tool (registerTool) vs legacy decorator
+     * @param uiResource URI of associated UI resource for dynamic rendering (optional)
      */
     registerTool(name, description, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handler, // Changed from Function to any to avoid confusion with built-in Function type
-    parameters, endpoint, authRequirements, responseType = "json", isNewStyle = false) {
-        const func = new models_1.Function(name, description, parameters, endpoint, authRequirements);
+    parameters, endpoint, authRequirements, isNewStyle = false, uiResource) {
+        const func = new models_1.Function(name, description, parameters, endpoint, authRequirements, uiResource);
         this.functions.push(func);
-        // Determine if this is a block tool
-        const isBlockTool = responseType === "block";
         // Register the actual endpoint
         this.router.post(endpoint, async (req, res) => {
             try {
@@ -82,18 +96,7 @@ class ToolsService {
                     }
                 }
                 console.log(`Tool ${name} returned:`, result);
-                // Return with appropriate content-type header
-                if (isBlockTool) {
-                    // Validate that block tools return a BlockResponse
-                    if (!(0, block_1.isBlockResponse)(result)) {
-                        throw new Error(`Block tool '${name}' must return a BlockResponse object, but returned ${typeof result}`);
-                    }
-                    res.set("Content-Type", "application/vnd.opal.block+json");
-                    res.json(result);
-                }
-                else {
-                    res.json(result);
-                }
+                res.json(result);
             }
             catch (error) {
                 console.error(`Error in tool ${name}:`, error);
@@ -104,11 +107,67 @@ class ToolsService {
         });
     }
     /**
-     * Initialize the discovery endpoint
+     * Initialize the discovery endpoint and resources/read endpoint
      */
     initRoutes() {
-        this.router.get("/discovery", (req, res) => {
-            res.json({ functions: this.functions.map((f) => f.toJSON()) });
+        this.router.get("/discovery", (_req, res) => {
+            res.json({
+                functions: this.functions.map((f) => f.toJSON()),
+            });
+        });
+        // POST /resources/read endpoint for MCP protocol
+        this.router.post("/resources/read", async (req, res) => {
+            try {
+                const { uri } = req.body;
+                if (!uri) {
+                    return res.status(400).json({
+                        error: "Missing required field: uri",
+                    });
+                }
+                console.log(`Received resource read request for URI: ${uri}`);
+                // Find the resource registration
+                const registration = this.resources.get(uri);
+                if (!registration) {
+                    return res.status(404).json({
+                        error: `Resource not found: ${uri}`,
+                    });
+                }
+                // Call handler and await result
+                const content = await registration.handler();
+                let textContent;
+                let mimeType = registration.metadata.mimeType;
+                // Check if handler returned a ProteusDocument
+                if (typeof content === "object" &&
+                    content !== null &&
+                    "$type" in content &&
+                    content.$type === "Document") {
+                    // Auto-serialize to JSON
+                    textContent = JSON.stringify(content);
+                    // Auto-set MIME type if not specified
+                    if (!mimeType) {
+                        mimeType = proteus_1.UI.MIME_TYPE;
+                    }
+                }
+                else if (typeof content === "string") {
+                    textContent = content;
+                }
+                else {
+                    throw new Error(`Resource handler for '${uri}' must return a string or ProteusDocument, but returned ${typeof content}`);
+                }
+                console.log(`Resource ${uri} returned content of length: ${textContent.length}`);
+                // Return the resource content directly
+                res.json({
+                    mimeType: mimeType || "text/plain",
+                    text: textContent,
+                    uri,
+                });
+            }
+            catch (error) {
+                console.error(`Error reading resource:`, error);
+                res.status(500).json({
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+            }
         });
         this.app.use(this.router);
     }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@optimizely-opal/opal-tools-sdk",
-  "version": "0.1.6-dev",
+  "version": "0.1.9-dev",
   "description": "SDK for creating Opal-compatible tools services",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "generate:block": "ts-node scripts/generate-block.ts",
+    "generate:proteus": "ts-node scripts/generate-proteus.ts",
     "lint": "bash scripts/lint.sh",
     "prepublishOnly": "npm run build",
     "test": "vitest run"

package/scripts/generate-proteus.ts

@@ -0,0 +1,135 @@
+#!/usr/bin/env ts-node
+/**
+ * Generate Adaptive Proteus Document types from JSON schema.
+ *
+ * This script uses json-schema-to-typescript to generate TypeScript interfaces
+ * from the proteus-document-spec.json schema. The generated types will replace the
+ * manual Proteus builders once we're ready to switch over.
+ *
+ * Usage:
+ *   npm run generate:proteus
+ */
+
+import * as fs from "fs";
+import { compile } from "json-schema-to-typescript";
+import * as path from "path";
+
+/**
+ * Generate builder functions and ProteusResponse class.
+ *
+ * The generated TypeScript interfaces are great for validation, but we want to
+ * keep the builder API (UI.Document(), etc.) for ease of use.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function generateBuilderCode(schema: any): string {
+  // Extract all Proteus components from definitions
+  const proteusComponents: Array<{ fullName: string; shortName: string }> = [];
+  const skipTypes = new Set([
+    "ProteusAtomicCondition",
+    "ProteusCondition",
+    "ProteusElement",
+    "ProteusEventHandler",
+    "ProteusNode",
+  ]);
+
+  if (schema.definitions) {
+    for (const componentName of Object.keys(schema.definitions)) {
+      if (
+        componentName.startsWith("Proteus") &&
+        !skipTypes.has(componentName)
+      ) {
+        // Extract the short name (e.g., "Document" from "ProteusDocument")
+        const shortName = componentName.substring(7); // Remove "Proteus" prefix
+        proteusComponents.push({ fullName: componentName, shortName });
+      }
+    }
+  }
+
+  // Sort components for consistent output
+  proteusComponents.sort((a, b) => a.shortName.localeCompare(b.shortName));
+
+  // Generate factory functions that return properly typed objects
+  const builderMethods = proteusComponents
+    .map(
+      ({ fullName, shortName }) =>
+        `  ${shortName}: (props: Omit<${fullName}, '$type'>): ${fullName} => ({ $type: '${shortName}' as const, ...props }),`,
+    )
+    .join("\n");
+
+  return `
+/**
+ * Builder namespace for Adaptive UI Document components.
+ *
+ * Usage:
+ *   UI.Document({ children: [...] })
+ *   UI.Heading({ children: "Title", level: "2" })
+ *   UI.Input({ name: "field_name", placeholder: "Enter..." })
+ */
+export const UI = {
+  MIME_TYPE: "application/vnd.opal.proteus+json" as const,
+${builderMethods}
+};
+`;
+}
+
+async function main() {
+  // Paths
+  const scriptDir = __dirname;
+  const sdkRoot = path.join(scriptDir, "..");
+  const schemaFile = path.join(sdkRoot, "..", "proteus-document-spec.json");
+  const outputFile = path.join(sdkRoot, "src", "proteus.ts");
+
+  if (!fs.existsSync(schemaFile)) {
+    console.error(`Error: Schema file not found at ${schemaFile}`);
+    process.exit(1);
+  }
+
+  try {
+    // Read the schema
+    const schema = JSON.parse(fs.readFileSync(schemaFile, "utf-8"));
+
+    // Create a new schema that references all definitions to force their generation
+    const schemaWithExports = {
+      ...schema,
+      definitions: schema.definitions,
+      // Export each definition by creating a oneOf at the root
+      oneOf: Object.keys(schema.definitions || {})
+        .filter((key) => key.startsWith("Proteus"))
+        .map((key) => ({ $ref: `#/definitions/${key}` })),
+    };
+
+    // Generate TypeScript types
+    const ts = await compile(schemaWithExports, "ProteusDocumentSchema", {
+      bannerComment: `/**
+ * Generated by json-schema-to-typescript
+ * DO NOT MODIFY - This file is auto-generated from proteus-document-spec.json
+ * Run 'npm run generate:proteus' to regenerate
+ */`,
+      declareExternallyReferenced: true,
+      strictIndexSignatures: true,
+      style: {
+        semi: true,
+        singleQuote: true,
+      },
+      unknownAny: true,
+      unreachableDefinitions: false,
+    });
+
+    // Post-process to add builder functions
+    const finalContent = ts + "\n" + generateBuilderCode(schema);
+
+    // Write the output file
+    fs.writeFileSync(outputFile, finalContent, "utf-8");
+
+    console.log(`Generated: ${outputFile}`);
+  } catch (error) {
+    console.error("Error: Generation failed");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});