skedyul 0.1.8 → 0.1.10

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

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

package/dist/cli/commands/diff.js

@@ -0,0 +1,295 @@
+"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.diffCommand = diffCommand;
+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 diff - Show what would change on deploy
+
+Usage:
+  skedyul dev diff [options]
+
+Options:
+  --config, -c        Path to config file (default: auto-detect skedyul.config.ts)
+  --registry, -r      Path to registry file to compare tools
+  --json              Output as JSON
+  --help, -h          Show this help message
+
+Description:
+  Compares your local skedyul.config.ts with the currently deployed configuration.
+  Shows changes in environment variables, tools, and workflows that would be
+  applied when deploying a new version.
+
+Examples:
+  # Show diff for config in current directory
+  skedyul dev diff
+
+  # Show diff with specific config
+  skedyul dev diff --config ./skedyul.config.ts
+
+  # Compare against specific registry
+  skedyul dev diff --registry ./dist/registry.js
+`);
+}
+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;
+}
+function compareEnvSchemas(newEnv, oldEnv) {
+    const newKeys = newEnv ? Object.keys(newEnv) : [];
+    const oldKeys = oldEnv ? Object.keys(oldEnv) : [];
+    const added = newKeys.filter((k) => !oldKeys.includes(k));
+    const removed = oldKeys.filter((k) => !newKeys.includes(k));
+    const changed = [];
+    // Check for changes in existing keys
+    for (const key of newKeys) {
+        if (oldKeys.includes(key)) {
+            const newDef = newEnv?.[key];
+            const oldDef = oldEnv?.[key];
+            const changes = [];
+            if (newDef?.required !== oldDef?.required) {
+                changes.push(newDef?.required
+                    ? 'now required'
+                    : 'no longer required');
+            }
+            if (newDef?.visibility !== oldDef?.visibility) {
+                changes.push(`visibility: ${oldDef?.visibility || 'visible'} → ${newDef?.visibility || 'visible'}`);
+            }
+            if (newDef?.label !== oldDef?.label) {
+                changes.push(`label changed`);
+            }
+            if (changes.length > 0) {
+                changed.push({ key, changes });
+            }
+        }
+    }
+    return { added, removed, changed };
+}
+async function diffCommand(args) {
+    const { flags } = (0, utils_1.parseArgs)(args);
+    if (flags.help || flags.h) {
+        printHelp();
+        return;
+    }
+    const jsonOutput = Boolean(flags.json);
+    // Find config file
+    let configPath = (flags.config || flags.c);
+    if (!configPath) {
+        const foundConfig = findConfigFile(process.cwd());
+        if (!foundConfig) {
+            if (jsonOutput) {
+                console.log(JSON.stringify({ error: 'No config file found' }));
+            }
+            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)) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ error: `Config file not found: ${configPath}` }));
+        }
+        else {
+            console.error(`❌ Config file not found: ${configPath}`);
+        }
+        process.exit(1);
+    }
+    // Load config
+    let config;
+    try {
+        config = await (0, config_1.loadConfig)(configPath);
+    }
+    catch (error) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+        }
+        else {
+            console.error(`❌ Failed to load config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(1);
+    }
+    // Validate config
+    const validation = (0, config_1.validateConfig)(config);
+    if (!validation.valid) {
+        if (jsonOutput) {
+            console.log(JSON.stringify({ error: 'Invalid config', errors: validation.errors }));
+        }
+        else {
+            console.error('❌ Config validation failed:');
+            for (const err of validation.errors) {
+                console.error(`   • ${err}`);
+            }
+        }
+        process.exit(1);
+    }
+    // For now, we compare against "no previous config" (new deploy scenario)
+    // In a full implementation, this would fetch the current deployed config from the server
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const previousConfig = undefined;
+    // Compare env schemas
+    const globalEnvDiff = compareEnvSchemas(config.env, previousConfig?.env);
+    const installEnvDiff = compareEnvSchemas(config.install?.env, previousConfig?.install?.env);
+    // Compare tools if registry path provided
+    let toolsDiff;
+    const registryPath = (flags.registry || flags.r);
+    if (registryPath) {
+        try {
+            const registry = await (0, utils_1.loadRegistry)(path.resolve(process.cwd(), registryPath));
+            const toolNames = Object.values(registry).map((t) => t.name);
+            // For now, show all tools as "added" since we don't have previous state
+            toolsDiff = {
+                added: toolNames,
+                removed: [],
+                total: toolNames.length,
+            };
+        }
+        catch (error) {
+            // Ignore registry loading errors for diff
+        }
+    }
+    const result = {
+        configPath,
+        globalEnv: globalEnvDiff,
+        installEnv: installEnvDiff,
+        tools: toolsDiff,
+        summary: {
+            hasChanges: globalEnvDiff.added.length > 0 ||
+                globalEnvDiff.removed.length > 0 ||
+                globalEnvDiff.changed.length > 0 ||
+                installEnvDiff.added.length > 0 ||
+                installEnvDiff.removed.length > 0 ||
+                installEnvDiff.changed.length > 0 ||
+                (toolsDiff?.added.length ?? 0) > 0 ||
+                (toolsDiff?.removed.length ?? 0) > 0,
+            globalEnvChanges: globalEnvDiff.added.length +
+                globalEnvDiff.removed.length +
+                globalEnvDiff.changed.length,
+            installEnvChanges: installEnvDiff.added.length +
+                installEnvDiff.removed.length +
+                installEnvDiff.changed.length,
+            toolChanges: (toolsDiff?.added.length ?? 0) + (toolsDiff?.removed.length ?? 0),
+        },
+    };
+    if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Human-readable output
+    console.log('');
+    console.log(`📦 ${config.name}${config.version ? ` v${config.version}` : ''}`);
+    console.log(`   ${configPath}`);
+    console.log('');
+    // Note about comparison
+    if (previousConfig === undefined) {
+        console.log('ℹ️  Comparing against empty state (new deployment)');
+        console.log('');
+    }
+    // Global env diff
+    if (result.summary.globalEnvChanges > 0) {
+        console.log('Global Environment Variables:');
+        for (const key of globalEnvDiff.added) {
+            const def = config.env?.[key];
+            const required = def?.required ? ' (required)' : '';
+            console.log(`  + ${key}${required}`);
+        }
+        for (const key of globalEnvDiff.removed) {
+            console.log(`  - ${key}`);
+        }
+        for (const item of globalEnvDiff.changed) {
+            console.log(`  ~ ${item.key}: ${item.changes.join(', ')}`);
+        }
+        console.log('');
+    }
+    // Install env diff
+    if (result.summary.installEnvChanges > 0) {
+        console.log('Install Environment Variables:');
+        for (const key of installEnvDiff.added) {
+            const def = config.install?.env?.[key];
+            const required = def?.required ? ' (required)' : '';
+            console.log(`  + ${key}${required}`);
+        }
+        for (const key of installEnvDiff.removed) {
+            console.log(`  - ${key}`);
+        }
+        for (const item of installEnvDiff.changed) {
+            console.log(`  ~ ${item.key}: ${item.changes.join(', ')}`);
+        }
+        console.log('');
+    }
+    // Tools diff
+    if (toolsDiff && result.summary.toolChanges > 0) {
+        console.log('Tools:');
+        for (const name of toolsDiff.added) {
+            console.log(`  + ${name}`);
+        }
+        for (const name of toolsDiff.removed) {
+            console.log(`  - ${name}`);
+        }
+        console.log('');
+    }
+    // Summary
+    if (result.summary.hasChanges) {
+        console.log('Summary:');
+        if (result.summary.globalEnvChanges > 0) {
+            console.log(`  • ${result.summary.globalEnvChanges} global env var change(s)`);
+        }
+        if (result.summary.installEnvChanges > 0) {
+            console.log(`  • ${result.summary.installEnvChanges} install env var change(s)`);
+        }
+        if (result.summary.toolChanges > 0) {
+            console.log(`  • ${result.summary.toolChanges} tool change(s)`);
+        }
+        console.log('');
+        console.log('✅ Ready to deploy');
+    }
+    else {
+        console.log('✅ No changes detected');
+    }
+}

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,222 @@
+"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)');
+    }
+    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>;