skedyul 0.1.7 → 0.1.9

package/dist/cli/commands/invoke.d.ts

@@ -0,0 +1 @@
+export declare function invokeCommand(args: string[]): Promise<void>;

package/dist/cli/commands/invoke.js

@@ -0,0 +1,223 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeCommand = invokeCommand;
+const z = __importStar(require("zod"));
+const utils_1 = require("../utils");
+function printHelp() {
+    console.log(`
+skedyul dev invoke - Invoke a tool from the registry
+
+Usage:
+  skedyul dev invoke <tool-name> [options]
+
+Arguments:
+  <tool-name>         Name of the tool to invoke (e.g., 'calendar_slots.list')
+
+Options:
+  --registry, -r      Path to the registry file (default: ./dist/registry.js)
+  --args, -a          JSON string of arguments to pass to the tool
+  --env, -e           Set environment variable (can be used multiple times)
+                      Format: --env KEY=VALUE
+  --env-file          Load environment variables from a file (e.g., .env.local)
+  --estimate          Run in estimate mode (billing only, no execution)
+  --help, -h          Show this help message
+
+Examples:
+  # Basic invocation
+  skedyul dev invoke my_tool --registry ./dist/registry.js --args '{"key": "value"}'
+
+  # With environment variables
+  skedyul dev invoke api_call \\
+    --registry ./dist/registry.js \\
+    --args '{"endpoint": "/users"}' \\
+    --env API_KEY=secret123 \\
+    --env BASE_URL=https://api.example.com
+
+  # Load env from file
+  skedyul dev invoke api_call \\
+    --registry ./dist/registry.js \\
+    --args '{"endpoint": "/users"}' \\
+    --env-file .env.local
+
+  # Estimate mode (billing only)
+  skedyul dev invoke expensive_tool \\
+    --registry ./dist/registry.js \\
+    --args '{"data": "test"}' \\
+    --estimate
+`);
+}
+function getZodSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (schema instanceof z.ZodType) {
+        return schema;
+    }
+    if (typeof schema === 'object' && schema !== null && 'zod' in schema) {
+        const schemaWithZod = schema;
+        if (schemaWithZod.zod instanceof z.ZodType) {
+            return schemaWithZod.zod;
+        }
+    }
+    return undefined;
+}
+async function invokeCommand(args) {
+    const { flags, positional } = (0, utils_1.parseArgs)(args);
+    if (flags.help || flags.h) {
+        printHelp();
+        return;
+    }
+    const toolName = positional[0];
+    if (!toolName) {
+        console.error('Error: Tool name is required');
+        console.error("Run 'skedyul dev invoke --help' for usage information.");
+        process.exit(1);
+    }
+    // Get registry path
+    const registryPath = (flags.registry || flags.r || './dist/registry.js');
+    // Parse tool arguments
+    let toolArgs = {};
+    const argsValue = flags.args || flags.a;
+    if (argsValue && typeof argsValue === 'string') {
+        try {
+            toolArgs = JSON.parse(argsValue);
+        }
+        catch {
+            console.error('Error: Invalid JSON in --args');
+            process.exit(1);
+        }
+    }
+    // Build environment
+    const env = { ...process.env };
+    // Load from env file if specified
+    const envFile = flags['env-file'];
+    if (envFile && typeof envFile === 'string') {
+        try {
+            const fileEnv = (0, utils_1.loadEnvFile)(envFile);
+            Object.assign(env, fileEnv);
+        }
+        catch (error) {
+            console.error(`Error loading env file: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    }
+    // Parse --env flags from raw args
+    const cliEnv = (0, utils_1.parseEnvFlags)(args);
+    Object.assign(env, cliEnv);
+    // Check for estimate mode
+    const estimateMode = Boolean(flags.estimate);
+    // Load registry
+    let registry;
+    try {
+        registry = await (0, utils_1.loadRegistry)(registryPath);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    // Find tool
+    let tool;
+    // Try exact match first
+    if (registry[toolName]) {
+        tool = registry[toolName];
+    }
+    else {
+        // Search by tool.name property
+        for (const [, entry] of Object.entries(registry)) {
+            if (entry.name === toolName) {
+                tool = entry;
+                break;
+            }
+        }
+    }
+    if (!tool) {
+        console.error(`Error: Tool "${toolName}" not found in registry`);
+        console.error('\nAvailable tools:');
+        for (const [key, entry] of Object.entries(registry)) {
+            console.error(`  - ${entry.name || key}`);
+        }
+        process.exit(1);
+    }
+    // Validate inputs if schema exists
+    const inputSchema = getZodSchema(tool.inputs);
+    let validatedArgs = toolArgs;
+    if (inputSchema) {
+        try {
+            validatedArgs = inputSchema.parse(toolArgs);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                console.error('Error: Invalid tool arguments');
+                for (const issue of error.issues) {
+                    console.error(`  - ${issue.path.join('.')}: ${issue.message}`);
+                }
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    // Create context
+    const context = {
+        env,
+        mode: estimateMode ? 'estimate' : 'execute',
+    };
+    // Execute tool
+    console.error(`Invoking tool: ${tool.name}`);
+    if (estimateMode) {
+        console.error('Mode: estimate (billing only)');
+    }
+    console.error('');
+    try {
+        const handler = tool.handler;
+        const result = await handler({
+            input: validatedArgs,
+            context,
+        });
+        // Output result
+        if (estimateMode) {
+            console.log((0, utils_1.formatJson)({ billing: result.billing }));
+        }
+        else {
+            console.log((0, utils_1.formatJson)({
+                output: result.output,
+                billing: result.billing,
+            }));
+        }
+    }
+    catch (error) {
+        console.error('Error executing tool:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function serveCommand(args: string[]): Promise<void>;

package/dist/cli/commands/serve.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveCommand = serveCommand;
+const utils_1 = require("../utils");
+const server_1 = require("../../server");
+function printHelp() {
+    console.log(`
+skedyul dev serve - Start a local MCP server for testing
+
+Usage:
+  skedyul dev serve [options]
+
+Options:
+  --registry, -r      Path to the registry file (default: ./dist/registry.js)
+  --port, -p          Port to listen on (default: 3000)
+  --name              Server name for MCP metadata (default: 'Local Dev Server')
+  --version           Server version for MCP metadata (default: '0.0.1')
+  --env, -e           Set environment variable (can be used multiple times)
+                      Format: --env KEY=VALUE
+  --env-file          Load environment variables from a file
+  --help, -h          Show this help message
+
+Examples:
+  # Start server on default port
+  skedyul dev serve --registry ./dist/registry.js
+
+  # Start on custom port
+  skedyul dev serve --registry ./dist/registry.js --port 3001
+
+  # With environment variables
+  skedyul dev serve \\
+    --registry ./dist/registry.js \\
+    --env API_KEY=secret123 \\
+    --env-file .env.local
+
+Endpoints:
+  POST /mcp            MCP JSON-RPC endpoint (tools/list, tools/call)
+  GET  /health         Health check endpoint
+  POST /estimate       Estimate billing for a tool call
+  POST /core           Core API methods (if configured)
+
+Testing with curl:
+  # List tools
+  curl -X POST http://localhost:3000/mcp \\
+    -H 'Content-Type: application/json' \\
+    -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
+
+  # Call a tool
+  curl -X POST http://localhost:3000/mcp \\
+    -H 'Content-Type: application/json' \\
+    -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"my_tool","arguments":{"key":"value"}}}'
+`);
+}
+async function serveCommand(args) {
+    const { flags } = (0, utils_1.parseArgs)(args);
+    if (flags.help || flags.h) {
+        printHelp();
+        return;
+    }
+    // Get registry path
+    const registryPath = (flags.registry || flags.r || './dist/registry.js');
+    // Get port
+    let port = 3000;
+    const portFlag = flags.port || flags.p;
+    if (portFlag && typeof portFlag === 'string') {
+        const parsed = parseInt(portFlag, 10);
+        if (!isNaN(parsed)) {
+            port = parsed;
+        }
+    }
+    // Get server metadata
+    const serverName = (flags.name || 'Local Dev Server');
+    const serverVersion = (flags.version || '0.0.1');
+    // Build environment
+    const envFile = flags['env-file'];
+    if (envFile && typeof envFile === 'string') {
+        try {
+            const fileEnv = (0, utils_1.loadEnvFile)(envFile);
+            Object.assign(process.env, fileEnv);
+        }
+        catch (error) {
+            console.error(`Error loading env file: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    }
+    // Parse --env flags from raw args
+    const cliEnv = (0, utils_1.parseEnvFlags)(args);
+    Object.assign(process.env, cliEnv);
+    // Load registry
+    let registry;
+    try {
+        registry = await (0, utils_1.loadRegistry)(registryPath);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    const toolCount = Object.keys(registry).length;
+    console.log(`Loaded ${toolCount} tool(s) from registry`);
+    // Create server
+    const server = (0, server_1.createSkedyulServer)({
+        computeLayer: 'dedicated',
+        metadata: {
+            name: serverName,
+            version: serverVersion,
+        },
+        defaultPort: port,
+    }, registry);
+    // Start listening
+    const dedicatedServer = server;
+    try {
+        await dedicatedServer.listen(port);
+        console.log(`\nEndpoints:`);
+        console.log(`  POST http://localhost:${port}/mcp      - MCP JSON-RPC`);
+        console.log(`  GET  http://localhost:${port}/health   - Health check`);
+        console.log(`  POST http://localhost:${port}/estimate - Billing estimate`);
+        console.log(`\nPress Ctrl+C to stop`);
+    }
+    catch (error) {
+        console.error('Failed to start server:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/tools.d.ts

@@ -0,0 +1 @@
+export declare function toolsCommand(args: string[]): Promise<void>;

package/dist/cli/commands/tools.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolsCommand = toolsCommand;
+const z = __importStar(require("zod"));
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const utils_1 = require("../utils");
+// Cast for Zod v4 compatibility
+const zodToJsonSchemaLoose = zod_to_json_schema_1.zodToJsonSchema;
+function printHelp() {
+    console.log(`
+skedyul dev tools - List all tools in the registry
+
+Usage:
+  skedyul dev tools [options]
+
+Options:
+  --registry, -r      Path to the registry file (default: ./dist/registry.js)
+  --json              Output as JSON (for programmatic use)
+  --verbose, -v       Show full input/output schemas
+  --help, -h          Show this help message
+
+Examples:
+  # List all tools
+  skedyul dev tools --registry ./dist/registry.js
+
+  # Output as JSON
+  skedyul dev tools --registry ./dist/registry.js --json
+
+  # Show full schemas
+  skedyul dev tools --registry ./dist/registry.js --verbose
+`);
+}
+function getZodSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (schema instanceof z.ZodType) {
+        return schema;
+    }
+    if (typeof schema === 'object' && schema !== null && 'zod' in schema) {
+        const schemaWithZod = schema;
+        if (schemaWithZod.zod instanceof z.ZodType) {
+            return schemaWithZod.zod;
+        }
+    }
+    return undefined;
+}
+function toJsonSchema(schema) {
+    if (!schema)
+        return undefined;
+    try {
+        return zodToJsonSchemaLoose(schema, {
+            target: 'jsonSchema7',
+            $refStrategy: 'none',
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+async function toolsCommand(args) {
+    const { flags } = (0, utils_1.parseArgs)(args);
+    if (flags.help || flags.h) {
+        printHelp();
+        return;
+    }
+    // Get registry path
+    const registryPath = (flags.registry || flags.r || './dist/registry.js');
+    const jsonOutput = Boolean(flags.json);
+    const verbose = Boolean(flags.verbose || flags.v);
+    // Load registry
+    let registry;
+    try {
+        registry = await (0, utils_1.loadRegistry)(registryPath);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+    const tools = [];
+    for (const [key, tool] of Object.entries(registry)) {
+        const inputZod = getZodSchema(tool.inputs);
+        const outputZod = getZodSchema(tool.outputSchema);
+        tools.push({
+            name: tool.name || key,
+            description: tool.description || '',
+            inputSchema: verbose ? toJsonSchema(inputZod) : undefined,
+            outputSchema: verbose ? toJsonSchema(outputZod) : undefined,
+        });
+    }
+    if (jsonOutput) {
+        console.log((0, utils_1.formatJson)(tools));
+        return;
+    }
+    // Human-readable output
+    console.log(`\nFound ${tools.length} tool(s) in registry:\n`);
+    for (const tool of tools) {
+        console.log(`  ${tool.name}`);
+        if (tool.description) {
+            console.log(`    ${tool.description}`);
+        }
+        if (verbose && tool.inputSchema) {
+            console.log('\n    Input Schema:');
+            const schemaStr = (0, utils_1.formatJson)(tool.inputSchema);
+            const indented = schemaStr.split('\n').map(line => `      ${line}`).join('\n');
+            console.log(indented);
+        }
+        if (verbose && tool.outputSchema) {
+            console.log('\n    Output Schema:');
+            const schemaStr = (0, utils_1.formatJson)(tool.outputSchema);
+            const indented = schemaStr.split('\n').map(line => `      ${line}`).join('\n');
+            console.log(indented);
+        }
+        console.log('');
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const invoke_1 = require("./commands/invoke");
+const tools_1 = require("./commands/tools");
+const serve_1 = require("./commands/serve");
+const args = process.argv.slice(2);
+function printUsage() {
+    console.log(`
+skedyul - Skedyul SDK CLI
+
+Usage:
+  skedyul dev <command> [options]
+
+Commands:
+  dev invoke <tool>   Invoke a tool from the registry
+  dev tools           List all tools in the registry
+  dev serve           Start a local MCP server
+
+Run 'skedyul dev <command> --help' for more information on a command.
+`);
+}
+function printDevUsage() {
+    console.log(`
+skedyul dev - Development tools for testing MCP servers locally
+
+Usage:
+  skedyul dev <command> [options]
+
+Commands:
+  invoke <tool>   Invoke a tool from the registry
+  tools           List all tools in the registry
+  serve           Start a local MCP server
+
+Examples:
+  skedyul dev invoke my_tool --registry ./dist/registry.js --args '{"key": "value"}'
+  skedyul dev tools --registry ./dist/registry.js
+  skedyul dev serve --registry ./dist/registry.js --port 3001
+
+Options:
+  --help, -h      Show help for a command
+`);
+}
+async function main() {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        printUsage();
+        process.exit(0);
+    }
+    const command = args[0];
+    if (command !== 'dev') {
+        console.error(`Unknown command: ${command}`);
+        console.error(`Run 'skedyul --help' for usage information.`);
+        process.exit(1);
+    }
+    const subCommand = args[1];
+    if (!subCommand || subCommand === '--help' || subCommand === '-h') {
+        printDevUsage();
+        process.exit(0);
+    }
+    const subArgs = args.slice(2);
+    switch (subCommand) {
+        case 'invoke':
+            await (0, invoke_1.invokeCommand)(subArgs);
+            break;
+        case 'tools':
+            await (0, tools_1.toolsCommand)(subArgs);
+            break;
+        case 'serve':
+            await (0, serve_1.serveCommand)(subArgs);
+            break;
+        default:
+            console.error(`Unknown dev command: ${subCommand}`);
+            console.error(`Run 'skedyul dev --help' for usage information.`);
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Error:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/cli/utils.d.ts

@@ -0,0 +1,25 @@
+import type { ToolRegistry } from '../types';
+export interface ParsedArgs {
+    flags: Record<string, string | boolean>;
+    positional: string[];
+}
+/**
+ * Parse command line arguments into flags and positional args
+ */
+export declare function parseArgs(args: string[]): ParsedArgs;
+/**
+ * Parse multiple --env flags into a record
+ */
+export declare function parseEnvFlags(args: string[]): Record<string, string>;
+/**
+ * Load environment variables from a .env file
+ */
+export declare function loadEnvFile(filePath: string): Record<string, string>;
+/**
+ * Load a registry from a JS/TS file
+ */
+export declare function loadRegistry(registryPath: string): Promise<ToolRegistry>;
+/**
+ * Format JSON for console output with optional color
+ */
+export declare function formatJson(data: unknown, pretty?: boolean): string;

package/dist/cli/utils.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.parseEnvFlags = parseEnvFlags;
+exports.loadEnvFile = loadEnvFile;
+exports.loadRegistry = loadRegistry;
+exports.formatJson = formatJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse command line arguments into flags and positional args
+ */
+function parseArgs(args) {
+    const flags = {};
+    const positional = [];
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            // Check if it's a key=value format
+            if (key.includes('=')) {
+                const [k, ...vParts] = key.split('=');
+                flags[k] = vParts.join('=');
+            }
+            else {
+                // Check if next arg is the value (not another flag)
+                const nextArg = args[i + 1];
+                if (nextArg && !nextArg.startsWith('-')) {
+                    flags[key] = nextArg;
+                    i++;
+                }
+                else {
+                    flags[key] = true;
+                }
+            }
+        }
+        else if (arg.startsWith('-') && arg.length === 2) {
+            const key = arg.slice(1);
+            const nextArg = args[i + 1];
+            if (nextArg && !nextArg.startsWith('-')) {
+                flags[key] = nextArg;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+        i++;
+    }
+    return { flags, positional };
+}
+/**
+ * Parse multiple --env flags into a record
+ */
+function parseEnvFlags(args) {
+    const env = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--env' || arg === '-e') {
+            const nextArg = args[i + 1];
+            if (nextArg && nextArg.includes('=')) {
+                const [key, ...valueParts] = nextArg.split('=');
+                env[key] = valueParts.join('=');
+                i++;
+            }
+        }
+        else if (arg.startsWith('--env=')) {
+            const value = arg.slice(6);
+            if (value.includes('=')) {
+                const [key, ...valueParts] = value.split('=');
+                env[key] = valueParts.join('=');
+            }
+        }
+    }
+    return env;
+}
+/**
+ * Load environment variables from a .env file
+ */
+function loadEnvFile(filePath) {
+    const env = {};
+    const absolutePath = path.resolve(process.cwd(), filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Environment file not found: ${absolutePath}`);
+    }
+    const content = fs.readFileSync(absolutePath, 'utf-8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const equalIndex = trimmed.indexOf('=');
+        if (equalIndex === -1) {
+            continue;
+        }
+        const key = trimmed.slice(0, equalIndex).trim();
+        let value = trimmed.slice(equalIndex + 1).trim();
+        // Remove surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        env[key] = value;
+    }
+    return env;
+}
+/**
+ * Load a registry from a JS/TS file
+ */
+async function loadRegistry(registryPath) {
+    const absolutePath = path.resolve(process.cwd(), registryPath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Registry file not found: ${absolutePath}`);
+    }
+    try {
+        // Use dynamic import for ES modules compatibility
+        const module = await Promise.resolve(`${absolutePath}`).then(s => __importStar(require(s)));
+        // Check for registry export (default or named)
+        const registry = module.registry || module.default?.registry || module.default;
+        if (!registry || typeof registry !== 'object') {
+            throw new Error(`Registry file must export a 'registry' object. Got: ${typeof registry}`);
+        }
+        // Validate it looks like a tool registry
+        const keys = Object.keys(registry);
+        if (keys.length === 0) {
+            throw new Error('Registry is empty');
+        }
+        // Check that at least one entry has expected tool shape
+        const firstTool = registry[keys[0]];
+        if (!firstTool || typeof firstTool.name !== 'string') {
+            throw new Error('Registry entries must have a "name" property. Is this a valid tool registry?');
+        }
+        return registry;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('Registry')) {
+            throw error;
+        }
+        throw new Error(`Failed to load registry from ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Format JSON for console output with optional color
+ */
+function formatJson(data, pretty = true) {
+    return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+}

package/dist/server.js

@@ -42,8 +42,20 @@ const http_1 = __importDefault(require("http"));
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 const z = __importStar(require("zod"));
-const zod_json_schema_compat_js_1 = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const service_1 = require("./core/service");
+const zodToJsonSchemaLoose = zod_to_json_schema_1.zodToJsonSchema;
+let toJsonSchemaCompatFn = null;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+    const compat = require('@modelcontextprotocol/sdk/server/zod-json-schema-compat.js');
+    if (compat?.toJsonSchemaCompat) {
+        toJsonSchemaCompatFn = compat.toJsonSchemaCompat;
+    }
+}
+catch {
+    toJsonSchemaCompatFn = null;
+}
 function normalizeBilling(billing) {
     if (!billing || typeof billing.credits !== 'number') {
         return { credits: 0 };
@@ -54,9 +66,15 @@ function toJsonSchema(schema) {
     if (!schema)
         return undefined;
     try {
-        return (0, zod_json_schema_compat_js_1.toJsonSchemaCompat)(schema, {
+        if (toJsonSchemaCompatFn) {
+            return toJsonSchemaCompatFn(schema, {
+                target: 'jsonSchema7',
+                pipeStrategy: 'input',
+            });
+        }
+        return zodToJsonSchemaLoose(schema, {
             target: 'jsonSchema7',
-            pipeStrategy: 'input',
+            $refStrategy: 'none',
         });
     }
     catch {

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "skedyul",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "The Skedyul SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "skedyul": "./dist/cli/index.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -23,7 +26,7 @@
   "author": "Skedyul <support@skedyul.com>",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.23.0",
     "zod": "^4.0.0",
     "zod-to-json-schema": "^3.23.0"
   },