skedyul 0.1.8 → 0.1.10

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/commands/validate.d.ts

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

package/dist/cli/commands/validate.js

@@ -0,0 +1,269 @@
+"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.validateCommand = validateCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("../utils");
+const config_1 = require("../../config");
+function printHelp() {
+    console.log(`
+skedyul dev validate - Validate skedyul.config.ts
+
+Usage:
+  skedyul dev validate [options]
+
+Options:
+  --config, -c        Path to config file (default: auto-detect skedyul.config.ts)
+  --verbose, -v       Show detailed validation output
+  --json              Output as JSON
+  --help, -h          Show this help message
+
+Examples:
+  # Validate config in current directory
+  skedyul dev validate
+
+  # Validate specific config file
+  skedyul dev validate --config ./skedyul.config.ts
+
+  # Verbose output
+  skedyul dev validate --verbose
+`);
+}
+function findConfigFile(startDir) {
+    for (const fileName of config_1.CONFIG_FILE_NAMES) {
+        const filePath = path.join(startDir, fileName);
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+async function validateCommand(args) {
+    const { flags } = (0, utils_1.parseArgs)(args);
+    if (flags.help || flags.h) {
+        printHelp();
+        return;
+    }
+    const verbose = Boolean(flags.verbose || flags.v);
+    const jsonOutput = Boolean(flags.json);
+    // Find config file
+    let configPath = (flags.config || flags.c);
+    if (!configPath) {
+        const foundConfig = findConfigFile(process.cwd());
+        if (!foundConfig) {
+            const result = {
+                valid: false,
+                configPath: '',
+                errors: [`No config file found. Create one of: ${config_1.CONFIG_FILE_NAMES.join(', ')}`],
+                warnings: [],
+            };
+            if (jsonOutput) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.error('❌ No config file found');
+                console.error(`   Create one of: ${config_1.CONFIG_FILE_NAMES.join(', ')}`);
+            }
+            process.exit(1);
+        }
+        configPath = foundConfig;
+    }
+    else {
+        configPath = path.resolve(process.cwd(), configPath);
+    }
+    if (!fs.existsSync(configPath)) {
+        const result = {
+            valid: false,
+            configPath,
+            errors: [`Config file not found: ${configPath}`],
+            warnings: [],
+        };
+        if (jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.error(`❌ Config file not found: ${configPath}`);
+        }
+        process.exit(1);
+    }
+    // Load and validate config
+    const warnings = [];
+    let config;
+    try {
+        config = await (0, config_1.loadConfig)(configPath);
+    }
+    catch (error) {
+        const result = {
+            valid: false,
+            configPath,
+            errors: [error instanceof Error ? error.message : String(error)],
+            warnings: [],
+        };
+        if (jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.error(`❌ Failed to load config: ${result.errors[0]}`);
+        }
+        process.exit(1);
+    }
+    // Validate schema
+    const validation = (0, config_1.validateConfig)(config);
+    // Check for common issues (warnings)
+    if (!config.computeLayer) {
+        warnings.push('No computeLayer specified. Will default to "dedicated".');
+    }
+    if (!config.tools) {
+        warnings.push('No tools path specified. Will default to "./src/registry.ts".');
+    }
+    if (!config.workflows) {
+        warnings.push('No workflows path specified. Will default to "./workflows".');
+    }
+    // Check if tools file exists
+    const toolsPath = config.tools || './src/registry.ts';
+    const absoluteToolsPath = path.resolve(path.dirname(configPath), toolsPath);
+    if (!fs.existsSync(absoluteToolsPath)) {
+        // Check for .js variant
+        const jsToolsPath = absoluteToolsPath.replace(/\.ts$/, '.js');
+        if (!fs.existsSync(jsToolsPath)) {
+            warnings.push(`Tools file not found: ${toolsPath}`);
+        }
+    }
+    // Check if workflows directory exists
+    const workflowsPath = config.workflows || './workflows';
+    const absoluteWorkflowsPath = path.resolve(path.dirname(configPath), workflowsPath);
+    if (!fs.existsSync(absoluteWorkflowsPath)) {
+        warnings.push(`Workflows directory not found: ${workflowsPath}`);
+    }
+    const envKeys = (0, config_1.getAllEnvKeys)(config);
+    const requiredInstallKeys = (0, config_1.getRequiredInstallEnvKeys)(config);
+    const result = {
+        valid: validation.valid,
+        configPath,
+        config: {
+            name: config.name,
+            version: config.version,
+            computeLayer: config.computeLayer,
+            runtime: config.runtime,
+            tools: config.tools,
+            workflows: config.workflows,
+            globalEnvKeys: envKeys.global,
+            installEnvKeys: envKeys.install,
+            requiredInstallEnvKeys: requiredInstallKeys,
+            appModels: config.install?.appModels?.map((m) => m.entityHandle) || [],
+        },
+        errors: validation.errors,
+        warnings,
+    };
+    if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(validation.valid ? 0 : 1);
+    }
+    // Human-readable output
+    console.log('');
+    console.log(`📦 ${config.name}${config.version ? ` v${config.version}` : ''}`);
+    console.log(`   ${configPath}`);
+    console.log('');
+    if (verbose) {
+        console.log('Configuration:');
+        console.log(`  Compute Layer: ${config.computeLayer || 'dedicated (default)'}`);
+        console.log(`  Runtime:       ${config.runtime || 'node-22 (default)'}`);
+        console.log(`  Tools:         ${config.tools || './src/registry.ts (default)'}`);
+        console.log(`  Workflows:     ${config.workflows || './workflows (default)'}`);
+        console.log('');
+        if (envKeys.global.length > 0) {
+            console.log('Global Environment Variables:');
+            for (const key of envKeys.global) {
+                const def = config.env?.[key];
+                const required = def?.required ? ' (required)' : '';
+                const visibility = def?.visibility === 'encrypted' ? ' 🔒' : '';
+                console.log(`  ${key}${required}${visibility}`);
+                if (def?.label)
+                    console.log(`    └─ ${def.label}`);
+            }
+            console.log('');
+        }
+        if (envKeys.install.length > 0) {
+            console.log('Install Environment Variables:');
+            for (const key of envKeys.install) {
+                const def = config.install?.env?.[key];
+                const required = def?.required ? ' (required)' : '';
+                const visibility = def?.visibility === 'encrypted' ? ' 🔒' : '';
+                console.log(`  ${key}${required}${visibility}`);
+                if (def?.label)
+                    console.log(`    └─ ${def.label}`);
+            }
+            console.log('');
+        }
+        if (config.install?.appModels && config.install.appModels.length > 0) {
+            console.log('App Models:');
+            for (const model of config.install.appModels) {
+                console.log(`  ${model.entityHandle}: ${model.label}`);
+            }
+            console.log('');
+        }
+    }
+    // Show errors
+    if (validation.errors.length > 0) {
+        console.log('❌ Validation Errors:');
+        for (const error of validation.errors) {
+            console.log(`   • ${error}`);
+        }
+        console.log('');
+    }
+    // Show warnings
+    if (warnings.length > 0) {
+        console.log('⚠️  Warnings:');
+        for (const warning of warnings) {
+            console.log(`   • ${warning}`);
+        }
+        console.log('');
+    }
+    // Final status
+    if (validation.valid) {
+        console.log('✅ Config is valid');
+        if (!verbose) {
+            console.log(`   ${envKeys.global.length} global env vars, ${envKeys.install.length} install env vars`);
+            if (requiredInstallKeys.length > 0) {
+                console.log(`   ${requiredInstallKeys.length} required install vars: ${requiredInstallKeys.join(', ')}`);
+            }
+        }
+    }
+    else {
+        console.log('❌ Config has errors');
+        process.exit(1);
+    }
+}

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,94 @@
+#!/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 validate_1 = require("./commands/validate");
+const diff_1 = require("./commands/diff");
+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
+  dev validate        Validate skedyul.config.ts
+  dev diff            Show what would change on deploy
+
+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
+  validate        Validate skedyul.config.ts
+  diff            Show what would change on deploy
+
+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
+  skedyul dev validate
+  skedyul dev diff
+
+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;
+        case 'validate':
+            await (0, validate_1.validateCommand)(subArgs);
+            break;
+        case 'diff':
+            await (0, diff_1.diffCommand)(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;