skedyul 0.1.8 → 0.1.10

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

@@ -0,0 +1,116 @@
+export type EnvVisibility = 'visible' | 'encrypted';
+export interface EnvVariableDefinition {
+    /** Human-readable label for the variable */
+    label: string;
+    /** Whether this variable is required */
+    required?: boolean;
+    /** Visibility setting (encrypted values are hidden in UI) */
+    visibility?: EnvVisibility;
+    /** Default value if not provided */
+    default?: string;
+    /** Description/help text */
+    description?: string;
+    /** Placeholder text for input fields */
+    placeholder?: string;
+}
+export type EnvSchema = Record<string, EnvVariableDefinition>;
+export interface AppModelDefinition {
+    /** Unique handle for the entity (e.g., 'client', 'patient') */
+    entityHandle: string;
+    /** Human-readable label */
+    label: string;
+    /** Description of what this model represents */
+    description?: string;
+}
+export interface InstallConfig {
+    /**
+     * Per-install environment variables.
+     * These are configured by the user when installing the app.
+     * Values are stored per-installation and can differ between installs.
+     */
+    env?: EnvSchema;
+    /**
+     * Model mappings required for this app.
+     * Users will map these to their CRM models during installation.
+     */
+    appModels?: AppModelDefinition[];
+}
+export type ComputeLayerType = 'serverless' | 'dedicated';
+export type RuntimeType = 'node-22' | 'node-20' | 'node-18';
+export interface SkedyulConfig {
+    /** App name */
+    name: string;
+    /** App version (semver) */
+    version?: string;
+    /** App description */
+    description?: string;
+    /** Compute layer: 'serverless' (Lambda) or 'dedicated' (ECS/Docker) */
+    computeLayer?: ComputeLayerType;
+    /** Runtime environment */
+    runtime?: RuntimeType;
+    /** Path to the tool registry file (default: './src/registry.ts') */
+    tools?: string;
+    /** Path to the workflows directory (default: './workflows') */
+    workflows?: string;
+    /**
+     * Global/version-level environment variables.
+     * These are baked into the container and are the same for all installations.
+     * Use for configuration that doesn't change per-install.
+     */
+    env?: EnvSchema;
+    /**
+     * Install-time configuration.
+     * Defines what users need to configure when installing the app.
+     */
+    install?: InstallConfig;
+}
+/**
+ * Define a Skedyul app configuration with full type safety.
+ *
+ * @example
+ * ```typescript
+ * // skedyul.config.ts
+ * import { defineConfig } from 'skedyul'
+ *
+ * export default defineConfig({
+ *   name: 'My App',
+ *   computeLayer: 'dedicated',
+ *   tools: './src/registry.ts',
+ *   env: {
+ *     LOG_LEVEL: { label: 'Log Level', default: 'info' },
+ *   },
+ *   install: {
+ *     env: {
+ *       API_KEY: { label: 'API Key', required: true, visibility: 'encrypted' },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare function defineConfig(config: SkedyulConfig): SkedyulConfig;
+/**
+ * Default config file names to search for
+ */
+export declare const CONFIG_FILE_NAMES: string[];
+/**
+ * Load a Skedyul config from a file path
+ */
+export declare function loadConfig(configPath: string): Promise<SkedyulConfig>;
+/**
+ * Validate a config object
+ */
+export declare function validateConfig(config: SkedyulConfig): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Get all required install env keys from a config
+ */
+export declare function getRequiredInstallEnvKeys(config: SkedyulConfig): string[];
+/**
+ * Get all env keys (both global and install) from a config
+ */
+export declare function getAllEnvKeys(config: SkedyulConfig): {
+    global: string[];
+    install: string[];
+};

package/dist/config.js

@@ -0,0 +1,233 @@
+"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.CONFIG_FILE_NAMES = void 0;
+exports.defineConfig = defineConfig;
+exports.loadConfig = loadConfig;
+exports.validateConfig = validateConfig;
+exports.getRequiredInstallEnvKeys = getRequiredInstallEnvKeys;
+exports.getAllEnvKeys = getAllEnvKeys;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper Function
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Define a Skedyul app configuration with full type safety.
+ *
+ * @example
+ * ```typescript
+ * // skedyul.config.ts
+ * import { defineConfig } from 'skedyul'
+ *
+ * export default defineConfig({
+ *   name: 'My App',
+ *   computeLayer: 'dedicated',
+ *   tools: './src/registry.ts',
+ *   env: {
+ *     LOG_LEVEL: { label: 'Log Level', default: 'info' },
+ *   },
+ *   install: {
+ *     env: {
+ *       API_KEY: { label: 'API Key', required: true, visibility: 'encrypted' },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+function defineConfig(config) {
+    return config;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Config Loading Utilities
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Default config file names to search for
+ */
+exports.CONFIG_FILE_NAMES = [
+    'skedyul.config.ts',
+    'skedyul.config.js',
+    'skedyul.config.mjs',
+    'skedyul.config.cjs',
+];
+/**
+ * Transpile a TypeScript config file to JavaScript
+ */
+async function transpileTypeScript(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    // Simple transpilation: remove type annotations and convert to CommonJS
+    // For more complex configs, users should pre-compile or use a JS config
+    let transpiled = content
+        // Remove import type statements
+        .replace(/import\s+type\s+\{[^}]+\}\s+from\s+['"][^'"]+['"]\s*;?\n?/g, '')
+        // Convert import { defineConfig } from 'skedyul' to require
+        .replace(/import\s+\{\s*defineConfig\s*\}\s+from\s+['"]skedyul['"]\s*;?\n?/g, '')
+        // Remove type annotations like : SkedyulConfig
+        .replace(/:\s*SkedyulConfig/g, '')
+        // Convert export default to module.exports
+        .replace(/export\s+default\s+/, 'module.exports = ')
+        // Replace defineConfig() wrapper with just the object
+        .replace(/defineConfig\s*\(\s*\{/, '{')
+        // Remove the closing paren from defineConfig
+        .replace(/\}\s*\)\s*;?\s*$/, '}');
+    return transpiled;
+}
+/**
+ * Load a Skedyul config from a file path
+ */
+async function loadConfig(configPath) {
+    const absolutePath = path.resolve(configPath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Config file not found: ${absolutePath}`);
+    }
+    const isTypeScript = absolutePath.endsWith('.ts');
+    try {
+        let moduleToLoad = absolutePath;
+        if (isTypeScript) {
+            // Transpile TypeScript to a temp JS file
+            const transpiled = await transpileTypeScript(absolutePath);
+            const tempDir = os.tmpdir();
+            const tempFile = path.join(tempDir, `skedyul-config-${Date.now()}.js`);
+            fs.writeFileSync(tempFile, transpiled);
+            moduleToLoad = tempFile;
+            try {
+                const module = require(moduleToLoad);
+                const config = module.default || module;
+                if (!config || typeof config !== 'object') {
+                    throw new Error('Config file must export a configuration object');
+                }
+                if (!config.name || typeof config.name !== 'string') {
+                    throw new Error('Config must have a "name" property');
+                }
+                return config;
+            }
+            finally {
+                // Clean up temp file
+                try {
+                    fs.unlinkSync(tempFile);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+        }
+        // For JS files, use dynamic import
+        const module = await Promise.resolve(`${moduleToLoad}`).then(s => __importStar(require(s)));
+        const config = module.default || module;
+        if (!config || typeof config !== 'object') {
+            throw new Error('Config file must export a configuration object');
+        }
+        if (!config.name || typeof config.name !== 'string') {
+            throw new Error('Config must have a "name" property');
+        }
+        return config;
+    }
+    catch (error) {
+        throw new Error(`Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Validate a config object
+ */
+function validateConfig(config) {
+    const errors = [];
+    // Required fields
+    if (!config.name) {
+        errors.push('Missing required field: name');
+    }
+    // Validate computeLayer
+    if (config.computeLayer && !['serverless', 'dedicated'].includes(config.computeLayer)) {
+        errors.push(`Invalid computeLayer: ${config.computeLayer}. Must be 'serverless' or 'dedicated'`);
+    }
+    // Validate runtime
+    if (config.runtime && !['node-22', 'node-20', 'node-18'].includes(config.runtime)) {
+        errors.push(`Invalid runtime: ${config.runtime}. Must be 'node-22', 'node-20', or 'node-18'`);
+    }
+    // Validate env schema
+    if (config.env) {
+        for (const [key, def] of Object.entries(config.env)) {
+            if (!def.label) {
+                errors.push(`env.${key}: Missing required field 'label'`);
+            }
+            if (def.visibility && !['visible', 'encrypted'].includes(def.visibility)) {
+                errors.push(`env.${key}: Invalid visibility '${def.visibility}'`);
+            }
+        }
+    }
+    // Validate install.env schema
+    if (config.install?.env) {
+        for (const [key, def] of Object.entries(config.install.env)) {
+            if (!def.label) {
+                errors.push(`install.env.${key}: Missing required field 'label'`);
+            }
+            if (def.visibility && !['visible', 'encrypted'].includes(def.visibility)) {
+                errors.push(`install.env.${key}: Invalid visibility '${def.visibility}'`);
+            }
+        }
+    }
+    // Validate appModels
+    if (config.install?.appModels) {
+        for (let i = 0; i < config.install.appModels.length; i++) {
+            const model = config.install.appModels[i];
+            if (!model.entityHandle) {
+                errors.push(`install.appModels[${i}]: Missing required field 'entityHandle'`);
+            }
+            if (!model.label) {
+                errors.push(`install.appModels[${i}]: Missing required field 'label'`);
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Get all required install env keys from a config
+ */
+function getRequiredInstallEnvKeys(config) {
+    if (!config.install?.env)
+        return [];
+    return Object.entries(config.install.env)
+        .filter(([, def]) => def.required)
+        .map(([key]) => key);
+}
+/**
+ * Get all env keys (both global and install) from a config
+ */
+function getAllEnvKeys(config) {
+    return {
+        global: config.env ? Object.keys(config.env) : [],
+        install: config.install?.env ? Object.keys(config.install.env) : [],
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export * from './types';
 export { server } from './server';
 export { workplace, communicationChannel } from './core/client';
+export { defineConfig, loadConfig, validateConfig, getRequiredInstallEnvKeys, getAllEnvKeys, CONFIG_FILE_NAMES, } from './config';
+export type { SkedyulConfig, EnvVariableDefinition, EnvSchema, EnvVisibility, InstallConfig, AppModelDefinition, ComputeLayerType, RuntimeType, } from './config';

package/dist/index.js

@@ -14,10 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.communicationChannel = exports.workplace = exports.server = void 0;
+exports.CONFIG_FILE_NAMES = exports.getAllEnvKeys = exports.getRequiredInstallEnvKeys = exports.validateConfig = exports.loadConfig = exports.defineConfig = exports.communicationChannel = exports.workplace = exports.server = void 0;
 __exportStar(require("./types"), exports);
 var server_1 = require("./server");
 Object.defineProperty(exports, "server", { enumerable: true, get: function () { return server_1.server; } });
 var client_1 = require("./core/client");
 Object.defineProperty(exports, "workplace", { enumerable: true, get: function () { return client_1.workplace; } });
 Object.defineProperty(exports, "communicationChannel", { enumerable: true, get: function () { return client_1.communicationChannel; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return config_1.defineConfig; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return config_1.validateConfig; } });
+Object.defineProperty(exports, "getRequiredInstallEnvKeys", { enumerable: true, get: function () { return config_1.getRequiredInstallEnvKeys; } });
+Object.defineProperty(exports, "getAllEnvKeys", { enumerable: true, get: function () { return config_1.getAllEnvKeys; } });
+Object.defineProperty(exports, "CONFIG_FILE_NAMES", { enumerable: true, get: function () { return config_1.CONFIG_FILE_NAMES; } });

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.8",
+  "version": "0.1.10",
   "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",