@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.75

package/dist/esm/layout/props-validator.js

@@ -0,0 +1,297 @@
+/**
+ * PropsValidator — React PropTypes style props validation.
+ * Ported 1:1 from packages/sdk-bak/src/services/props-validator.service.ts.
+ * Only the import path is changed.
+ */
+import { PropsValidationError, } from './types';
+export class PropsValidator {
+    defaultMode;
+    constructor(options = {}) {
+        this.defaultMode = options.defaultMode ?? 'lenient';
+    }
+    validate(props, schema, mode = this.defaultMode) {
+        const errors = [];
+        const resolvedProps = this.validateObject(props ?? {}, schema, mode, ['props'], errors);
+        if (errors.length > 0 && mode === 'strict') {
+            throw new PropsValidationError('Props validation failed in strict mode', errors);
+        }
+        return {
+            valid: errors.length === 0,
+            props: resolvedProps,
+            errors,
+        };
+    }
+    validateObject(provided, schema, mode, pathSegments, errors) {
+        const sanitized = {};
+        if (mode === 'strict') {
+            for (const key of Object.keys(provided)) {
+                if (!schema[key]) {
+                    errors.push({
+                        path: this.buildPath([...pathSegments, key]),
+                        message: `Unknown prop '${key}'`,
+                        value: provided[key],
+                    });
+                }
+            }
+        }
+        for (const [key, propSchema] of Object.entries(schema)) {
+            const fullPath = [...pathSegments, key];
+            const rawValue = provided[key];
+            const result = this.resolveProp(rawValue, propSchema, fullPath, mode, errors);
+            if (result.shouldAssign) {
+                sanitized[key] = result.value;
+            }
+        }
+        return sanitized;
+    }
+    resolveProp(value, schema, pathSegments, mode, errors) {
+        const path = this.buildPath(pathSegments);
+        if (this.isNil(value)) {
+            if (schema.isRequired) {
+                errors.push({
+                    path,
+                    message: `Required prop '${pathSegments[pathSegments.length - 1]}' is missing`,
+                });
+            }
+            if (schema.defaultValue !== undefined) {
+                return { shouldAssign: true, value: this.cloneValue(schema.defaultValue) };
+            }
+            if (schema.type === 'shape' && schema.shape) {
+                const nestedDefaults = this.applyDefaults(schema.shape);
+                if (Object.keys(nestedDefaults).length > 0) {
+                    return { shouldAssign: true, value: nestedDefaults };
+                }
+            }
+            return { shouldAssign: false };
+        }
+        const typeResult = this.validateType(value, schema, pathSegments, mode, errors);
+        if (!typeResult.valid) {
+            if (schema.type === 'shape' &&
+                typeResult.value &&
+                this.isPlainObject(typeResult.value)) {
+                return { shouldAssign: true, value: typeResult.value };
+            }
+            errors.push({ path, message: typeResult.error ?? 'Invalid value', value });
+            if (schema.defaultValue !== undefined) {
+                return { shouldAssign: true, value: this.cloneValue(schema.defaultValue) };
+            }
+            if (schema.type === 'shape' && schema.shape) {
+                const nestedDefaults = this.applyDefaults(schema.shape);
+                if (Object.keys(nestedDefaults).length > 0) {
+                    return { shouldAssign: true, value: nestedDefaults };
+                }
+            }
+            return { shouldAssign: false };
+        }
+        return { shouldAssign: true, value: typeResult.value };
+    }
+    validateType(value, schema, pathSegments, mode, errors) {
+        const { type } = schema;
+        switch (type) {
+            case 'string':
+                return this.validateString(value, schema);
+            case 'number':
+                return this.validateNumber(value, schema);
+            case 'bool':
+                return this.validateBoolean(value);
+            case 'array':
+                return this.validateArray(value, schema);
+            case 'arrayOf':
+                return this.validateArrayOf(value, schema, pathSegments, mode, errors);
+            case 'object':
+                return this.validatePlainObject(value);
+            case 'shape':
+                return this.validateShape(value, schema, pathSegments, mode, errors);
+            case 'oneOfType':
+                return this.validateOneOfType(value, schema);
+            case 'func':
+                return this.validateFunction(value);
+            case 'node':
+                return { valid: true, value };
+            default:
+                return { valid: true, value };
+        }
+    }
+    validateString(value, schema) {
+        if (typeof value !== 'string') {
+            return { valid: false, error: `Expected string, got ${this.describeType(value)}` };
+        }
+        if (schema.oneOf && !schema.oneOf.includes(value)) {
+            return { valid: false, error: `Expected one of: ${schema.oneOf.join(', ')}` };
+        }
+        if (schema.minLength !== undefined && value.length < schema.minLength) {
+            return { valid: false, error: `String length must be >= ${schema.minLength}` };
+        }
+        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+            return { valid: false, error: `String length must be <= ${schema.maxLength}` };
+        }
+        if (schema.pattern) {
+            const pattern = new RegExp(schema.pattern);
+            if (!pattern.test(value)) {
+                return { valid: false, error: `String does not match pattern ${schema.pattern}` };
+            }
+        }
+        return { valid: true, value };
+    }
+    validateNumber(value, schema) {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+            return { valid: false, error: `Expected number, got ${this.describeType(value)}` };
+        }
+        if (schema.min !== undefined && value < schema.min) {
+            return { valid: false, error: `Number must be >= ${schema.min}` };
+        }
+        if (schema.max !== undefined && value > schema.max) {
+            return { valid: false, error: `Number must be <= ${schema.max}` };
+        }
+        if (schema.oneOf && !schema.oneOf.includes(value)) {
+            return { valid: false, error: `Expected one of: ${schema.oneOf.join(', ')}` };
+        }
+        return { valid: true, value };
+    }
+    validateBoolean(value) {
+        if (typeof value !== 'boolean') {
+            return { valid: false, error: `Expected boolean, got ${this.describeType(value)}` };
+        }
+        return { valid: true, value };
+    }
+    validateArray(value, schema) {
+        if (!Array.isArray(value)) {
+            return { valid: false, error: `Expected array, got ${this.describeType(value)}` };
+        }
+        if (schema.minLength !== undefined && value.length < schema.minLength) {
+            return { valid: false, error: `Array length must be >= ${schema.minLength}` };
+        }
+        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+            return { valid: false, error: `Array length must be <= ${schema.maxLength}` };
+        }
+        return { valid: true, value: [...value] };
+    }
+    validateArrayOf(value, schema, pathSegments, mode, errors) {
+        const base = this.validateArray(value, schema);
+        if (!base.valid)
+            return base;
+        const itemValues = [];
+        const itemType = schema.itemType;
+        const itemOneOf = schema.itemOneOf;
+        const beforeErrors = errors.length;
+        base.value.forEach((item, index) => {
+            const itemPath = [...pathSegments, String(index)];
+            if (itemType) {
+                const result = this.validateType(item, { type: itemType }, itemPath, mode, errors);
+                if (!result.valid) {
+                    errors.push({
+                        path: this.buildPath(itemPath),
+                        message: result.error ?? 'Invalid array item',
+                        value: item,
+                    });
+                }
+                else {
+                    itemValues.push(result.value);
+                }
+            }
+            else {
+                itemValues.push(item);
+            }
+            if (itemOneOf && !itemOneOf.includes(item)) {
+                errors.push({
+                    path: this.buildPath(itemPath),
+                    message: `Array item must be one of: ${itemOneOf.join(', ')}`,
+                    value: item,
+                });
+            }
+        });
+        return { valid: errors.length === beforeErrors, value: itemValues };
+    }
+    validatePlainObject(value) {
+        if (!this.isPlainObject(value)) {
+            return { valid: false, error: `Expected object, got ${this.describeType(value)}` };
+        }
+        return { valid: true, value: { ...value } };
+    }
+    validateFunction(value) {
+        if (typeof value !== 'function') {
+            return { valid: false, error: `Expected function, got ${this.describeType(value)}` };
+        }
+        return { valid: true, value };
+    }
+    validateShape(value, schema, pathSegments, mode, errors) {
+        if (!this.isPlainObject(value)) {
+            return { valid: false, error: `Expected object, got ${this.describeType(value)}` };
+        }
+        const beforeErrors = errors.length;
+        const nested = this.validateObject(value, schema.shape ?? {}, mode, pathSegments, errors);
+        return { valid: errors.length === beforeErrors, value: nested };
+    }
+    validateOneOfType(value, schema) {
+        const types = schema.types ?? [];
+        const matches = types.some(typeName => this.matchesType(value, typeName));
+        if (!matches) {
+            return {
+                valid: false,
+                error: `Value does not match any allowed type: ${types.join(', ')}`,
+            };
+        }
+        return { valid: true, value };
+    }
+    matchesType(value, typeName) {
+        switch (typeName) {
+            case 'string': return typeof value === 'string';
+            case 'number': return typeof value === 'number' && !Number.isNaN(value);
+            case 'bool':
+            case 'boolean': return typeof value === 'boolean';
+            case 'array': return Array.isArray(value);
+            case 'object': return this.isPlainObject(value);
+            case 'func':
+            case 'function': return typeof value === 'function';
+            case 'shape': return this.isPlainObject(value);
+            case 'node': return value === null || value === undefined || typeof value !== 'symbol';
+            default: return true;
+        }
+    }
+    applyDefaults(schema) {
+        const defaults = {};
+        for (const [key, propSchema] of Object.entries(schema)) {
+            if (propSchema.defaultValue !== undefined) {
+                defaults[key] = this.cloneValue(propSchema.defaultValue);
+                continue;
+            }
+            if (propSchema.type === 'shape' && propSchema.shape) {
+                const nestedDefaults = this.applyDefaults(propSchema.shape);
+                if (Object.keys(nestedDefaults).length > 0) {
+                    defaults[key] = nestedDefaults;
+                }
+            }
+        }
+        return defaults;
+    }
+    cloneValue(value) {
+        if (Array.isArray(value)) {
+            return value.map(item => this.cloneValue(item));
+        }
+        if (this.isPlainObject(value)) {
+            const cloned = {};
+            for (const [key, nested] of Object.entries(value)) {
+                cloned[key] = this.cloneValue(nested);
+            }
+            return cloned;
+        }
+        return value;
+    }
+    isPlainObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    isNil(value) {
+        return value === null || value === undefined;
+    }
+    buildPath(segments) {
+        return segments.join('.');
+    }
+    describeType(value) {
+        if (Array.isArray(value))
+            return 'array';
+        if (value === null)
+            return 'null';
+        return typeof value;
+    }
+}
+//# sourceMappingURL=props-validator.js.map

package/dist/esm/layout/renderer.js

@@ -0,0 +1,180 @@
+/**
+ * LayoutRenderer — Handlebars-based layout rendering.
+ * Ported from packages/sdk-bak/src/services/layout-renderer.service.ts.
+ * Excluded: formatConversation helper, registerTemplateHelpers (exec/shell-quote).
+ * Exec is handled separately by TemplateEngine in the facade layer.
+ */
+import Handlebars from 'handlebars';
+import { PropsValidator } from './props-validator';
+import { PropsValidationError as LayoutPropsValidationError } from './types';
+export { PropsValidationError } from './types';
+/**
+ * LayoutRenderer — renders layout templates with Handlebars.
+ */
+export class LayoutRenderer {
+    handlebars;
+    propsValidator;
+    constructor(propsValidator) {
+        this.handlebars = Handlebars.create();
+        this.propsValidator = propsValidator ?? new PropsValidator();
+        this.registerHelpers();
+    }
+    /**
+     * Render a layout template with the given context.
+     */
+    render(layout, context, options = {}) {
+        try {
+            const preparedContext = this.prepareRenderContext(layout, context, options);
+            const template = this.handlebars.compile(layout.template, { noEscape: true });
+            return template(preparedContext);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Template rendering failed for layout '${layout.id}': ${error.message}`);
+            }
+            throw new Error(`Unknown error rendering layout '${layout.id}'`);
+        }
+    }
+    /**
+     * Validate props against schema.
+     */
+    validate(props, propsSchema, mode = 'lenient') {
+        return this.executeValidation(props, propsSchema, mode);
+    }
+    /**
+     * Merge default props and runtime props, then validate.
+     */
+    resolveProps(layout, props, mode = 'lenient') {
+        const mergedProps = this.mergeProps(layout.defaultProps, props);
+        if (!layout.propsSchema || Object.keys(layout.propsSchema).length === 0) {
+            return { valid: true, props: mergedProps, errors: [] };
+        }
+        return this.executeValidation(mergedProps, layout.propsSchema, mode);
+    }
+    prepareRenderContext(layout, context, options) {
+        const { validationMode = 'lenient', skipValidation = false } = options;
+        const resolvedProps = skipValidation
+            ? this.mergeProps(layout.defaultProps, context.props)
+            : this.resolveProps(layout, context.props, validationMode).props;
+        return {
+            ...context,
+            vars: this.sanitizeVars(context.vars),
+            props: resolvedProps,
+        };
+    }
+    /**
+     * Register built-in Handlebars helpers (no exec, no formatConversation).
+     */
+    registerHelpers() {
+        // Built-in block helpers
+        if (Handlebars.helpers.each) {
+            this.handlebars.registerHelper('each', Handlebars.helpers.each);
+        }
+        if (Handlebars.helpers.if) {
+            this.handlebars.registerHelper('if', Handlebars.helpers.if);
+        }
+        if (Handlebars.helpers.unless) {
+            this.handlebars.registerHelper('unless', Handlebars.helpers.unless);
+        }
+        if (Handlebars.helpers.with) {
+            this.handlebars.registerHelper('with', Handlebars.helpers.with);
+        }
+        this.handlebars.registerHelper('eq', function (a, b) {
+            return a === b;
+        });
+        this.handlebars.registerHelper('ne', function (a, b) {
+            return a !== b;
+        });
+        this.handlebars.registerHelper('gt', function (a, b) {
+            return a > b;
+        });
+        this.handlebars.registerHelper('lt', function (a, b) {
+            return a < b;
+        });
+        this.handlebars.registerHelper('json', function (obj) {
+            return new Handlebars.SafeString(JSON.stringify(obj));
+        });
+        this.handlebars.registerHelper('raw', function (options) {
+            return typeof options?.fn === 'function' ? options.fn(this) : '';
+        });
+        this.handlebars.registerHelper('escapeHandlebars', function (text) {
+            if (typeof text !== 'string')
+                return '';
+            return text.replace(/\{\{/g, '&#123;&#123;').replace(/\}\}/g, '&#125;&#125;');
+        });
+        this.handlebars.registerHelper('formatFileSize', function (bytes) {
+            if (bytes === 0)
+                return '0 B';
+            const sizes = ['B', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(1024));
+            return Math.round((bytes / Math.pow(1024, i)) * 100) / 100 + ' ' + sizes[i];
+        });
+    }
+    executeValidation(props, propsSchema, mode) {
+        try {
+            return this.propsValidator.validate(props, propsSchema, mode);
+        }
+        catch (error) {
+            if (error instanceof LayoutPropsValidationError && error.errors && error.errors.length > 0) {
+                const firstError = error.errors[0];
+                if (firstError) {
+                    throw new LayoutPropsValidationError(firstError.message, error.errors);
+                }
+            }
+            throw error;
+        }
+    }
+    mergeProps(defaultProps, overrides) {
+        const base = this.cloneDeep(defaultProps ?? {});
+        if (!overrides)
+            return base;
+        return this.deepMerge(base, overrides);
+    }
+    deepMerge(target, source) {
+        for (const [key, value] of Object.entries(source)) {
+            if (this.isPlainObject(value)) {
+                const existing = target[key];
+                target[key] = this.deepMerge(this.isPlainObject(existing) ? existing : {}, value);
+                continue;
+            }
+            if (Array.isArray(value)) {
+                target[key] = this.cloneDeep(value);
+                continue;
+            }
+            target[key] = value;
+        }
+        return target;
+    }
+    cloneDeep(value) {
+        if (Array.isArray(value)) {
+            return value.map(item => this.cloneDeep(item));
+        }
+        if (this.isPlainObject(value)) {
+            const cloned = {};
+            for (const [key, nested] of Object.entries(value)) {
+                cloned[key] = this.cloneDeep(nested);
+            }
+            return cloned;
+        }
+        return value;
+    }
+    isPlainObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    sanitizeVars(vars) {
+        if (!vars)
+            return {};
+        const sanitizedVars = { ...vars };
+        if (typeof vars.user_input === 'string') {
+            sanitizedVars.user_input_raw = vars.user_input;
+            const escapedHandlebars = vars.user_input
+                .replace(/\{\{\{/g, '&#123;&#123;&#123;')
+                .replace(/\}\}\}/g, '&#125;&#125;&#125;')
+                .replace(/\{\{/g, '&#123;&#123;')
+                .replace(/\}\}/g, '&#125;&#125;');
+            sanitizedVars.user_input = this.handlebars.escapeExpression(escapedHandlebars);
+        }
+        return sanitizedVars;
+    }
+}
+//# sourceMappingURL=renderer.js.map

package/dist/esm/layout/types.js

@@ -0,0 +1,31 @@
+/**
+ * Layout system type definitions for CrewX SDK.
+ * Ported from packages/sdk-bak/src/types/layout.types.ts (1:1, import path only changed).
+ */
+/**
+ * Error thrown when layout loading fails.
+ */
+export class LayoutLoadError extends Error {
+    layoutId;
+    cause;
+    constructor(message, layoutId, cause) {
+        super(message);
+        this.layoutId = layoutId;
+        this.cause = cause;
+        this.name = 'LayoutLoadError';
+    }
+}
+/**
+ * Error thrown when props validation fails (strict mode).
+ */
+export class PropsValidationError extends Error {
+    errors;
+    cause;
+    constructor(message, errors = [], cause) {
+        super(message);
+        this.errors = errors;
+        this.cause = cause;
+        this.name = 'PropsValidationError';
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/esm/parallel/agent-runtime.js

@@ -0,0 +1,21 @@
+/**
+ * Minimal AgentRuntime for the parallel execution module.
+ * Provides query/execute methods to run agent operations.
+ * Tests use vi.spyOn(AgentRuntime.prototype, 'query') to mock these methods.
+ */
+/**
+ * Runtime that executes agent query/execute operations.
+ * Default implementation throws — callers must inject a working provider
+ * or mock the prototype methods in tests.
+ */
+export class AgentRuntime {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async query(_request) {
+        throw new Error('AgentRuntime.query is not implemented. Provide a subclass or mock AgentRuntime.prototype.query.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async execute(_request) {
+        throw new Error('AgentRuntime.execute is not implemented. Provide a subclass or mock AgentRuntime.prototype.execute.');
+    }
+}
+//# sourceMappingURL=agent-runtime.js.map