@crewx/sdk 0.8.0-rc.79 → 0.8.0-rc.80

package/dist/esm/hooks/define.js

@@ -1,10 +0,0 @@
-import { ToolObserverPlugin } from './observer';
-export function definePlugin(def) {
-    return new (class extends ToolObserverPlugin {
-        name = def.name;
-        version = def.version;
-        on = def.on;
-        run = def.run;
-    })();
-}
-//# sourceMappingURL=define.js.map

package/dist/esm/hooks/dispatch.js

@@ -1,76 +0,0 @@
-import { resolve, relative } from 'path';
-const MAX_REASON_LENGTH = 200;
-export function sanitizeDenyReason(reason) {
-    const cleaned = reason.replace(/[\x00-\x1f\x7f]/g, '');
-    if (cleaned.length <= MAX_REASON_LENGTH) {
-        return cleaned;
-    }
-    return cleaned.slice(0, MAX_REASON_LENGTH - 11) + ' [redacted]';
-}
-export function isPathSafe(pluginPath, projectRoot) {
-    const resolved = resolve(pluginPath);
-    const root = resolve(projectRoot);
-    const rel = relative(root, resolved);
-    if (rel.startsWith('..') || resolve(resolved).startsWith('/etc/') || resolve(resolved).startsWith('/usr/')) {
-        return false;
-    }
-    if (resolved.includes('node_modules')) {
-        return false;
-    }
-    return true;
-}
-export function buildHookContext(input, cwd) {
-    return {
-        event: 'beforeTool',
-        traceId: input.tool_use_id || '',
-        agent: { id: '', role: '', team: '' },
-        provider: 'cli/claude',
-        thread: { id: '' },
-        tool: {
-            name: input.tool_name,
-            rawName: input.tool_name,
-            input: input.tool_input,
-        },
-        cwd: cwd || input.cwd,
-        sessionId: input.session_id,
-        pass: () => ({ type: 'pass' }),
-        deny: (r) => ({ type: 'deny', reason: r }),
-        inject: (m) => ({ type: 'inject', message: m }),
-        modify: (p) => ({ type: 'modify', patch: p }),
-    };
-}
-export async function evaluateHook(plugin, input, cwd) {
-    const ctx = buildHookContext(input, cwd);
-    const result = await plugin.run(ctx);
-    const baseOutput = {
-        hookSpecificOutput: {
-            hookEventName: input.hook_event_name,
-            permissionDecision: 'allow',
-        },
-    };
-    switch (result.type) {
-        case 'pass':
-            return { exitCode: 0, stdout: baseOutput };
-        case 'deny': {
-            const sanitizedReason = sanitizeDenyReason(result.reason);
-            return {
-                exitCode: 2,
-                stdout: {
-                    hookSpecificOutput: {
-                        hookEventName: input.hook_event_name,
-                        permissionDecision: 'deny',
-                        permissionDecisionReason: sanitizedReason,
-                    },
-                },
-            };
-        }
-        case 'inject':
-        case 'modify':
-            console.error(`[crewx] Hook result type '${result.type}' is not supported in Phase 0. ` +
-                `Plugin: ${plugin.name}. Treating as pass.`);
-            return { exitCode: 0, stdout: baseOutput };
-        default:
-            return { exitCode: 0, stdout: baseOutput };
-    }
-}
-//# sourceMappingURL=dispatch.js.map

package/dist/esm/hooks/index.js

@@ -1,6 +0,0 @@
-export { ToolObserverPlugin } from './observer';
-export { HookPlugin, defineHookPlugin } from './plugin';
-export { definePlugin } from './define';
-export { Tools } from './types';
-export { evaluateHook, sanitizeDenyReason, isPathSafe, buildHookContext, } from './dispatch';
-//# sourceMappingURL=index.js.map

package/dist/esm/hooks/observer.js

@@ -1,56 +0,0 @@
-import { CrewxPlugin } from '../plugin';
-export class ToolObserverPlugin extends CrewxPlugin {
-    unsubs = [];
-    attach(crewx) {
-        if (this.on.beforeTool) {
-            const unsub = crewx.on('tool:observed:before', async (e) => {
-                if (!this.matchesTool(this.on.beforeTool, e.tool.name))
-                    return;
-                const ctx = this.buildContext('beforeTool', e);
-                await this.run(ctx);
-            });
-            this.unsubs.push(unsub);
-        }
-        if (this.on.afterTool) {
-            const unsub = crewx.on('tool:observed:after', async (e) => {
-                if (!this.matchesTool(this.on.afterTool, e.tool.name))
-                    return;
-                const ctx = this.buildContext('afterTool', e);
-                await this.run(ctx);
-            });
-            this.unsubs.push(unsub);
-        }
-    }
-    async detach(_crewx) {
-        for (const unsub of this.unsubs)
-            unsub();
-        this.unsubs = [];
-    }
-    matchesTool(filter, toolName) {
-        if (filter === true)
-            return true;
-        return filter.includes(toolName);
-    }
-    buildContext(event, e) {
-        return {
-            event,
-            traceId: e.traceId,
-            agent: {
-                id: e.agentId || e.agentRef,
-                role: '',
-                team: '',
-            },
-            provider: e.provider,
-            thread: { id: e.threadId || '' },
-            tool: {
-                name: e.tool.name,
-                rawName: e.tool.rawName,
-                input: 'input' in e.tool ? e.tool.input : undefined,
-            },
-            cwd: process.cwd(),
-            sessionId: e.sessionId || '',
-            pass: () => ({ type: 'pass' }),
-        };
-    }
-}
-//# sourceMappingURL=observer.js.map

package/dist/esm/hooks/plugin.js

@@ -1,12 +0,0 @@
-export class HookPlugin {
-    capabilities = { required: [] };
-}
-export function defineHookPlugin(def) {
-    return new (class extends HookPlugin {
-        name = def.name;
-        version = def.version;
-        capabilities = def.capabilities ?? { required: [] };
-        run = def.run;
-    })();
-}
-//# sourceMappingURL=plugin.js.map

package/dist/esm/hooks/types.js

@@ -1,9 +0,0 @@
-export const Tools = {
-    FileRead: 'file.read',
-    FileWrite: 'file.write',
-    FileEdit: 'file.edit',
-    Shell: 'shell',
-    Search: 'search',
-    Other: 'other',
-};
-//# sourceMappingURL=types.js.map

package/dist/esm/index.browser.js

@@ -1,15 +0,0 @@
-/**
- * @crewx/sdk browser entry point.
- *
- * Exports only browser-safe modules — no Node.js dependencies
- * (child_process, fs, path, crypto, events).
- */
-// Browser-safe facade
-export { Crewx } from './facade/Crewx.browser.js';
-// Browser-safe provider bridge (registry only, no CLI spawn)
-export { registerProviderFactory, createProvider, ProviderError } from './provider/bridge.browser.js';
-// Config — browser-safe (no fs import)
-export { parseYamlContent, ConfigLoadError } from './config/loader.browser.js';
-// Platform adapters
-export { BrowserFsAdapter } from './platform/BrowserFsAdapter.js';
-//# sourceMappingURL=index.browser.js.map

package/dist/esm/index.js

@@ -1,60 +0,0 @@
-/**
- * @crewx/sdk public API surface.
- */
-// Main facade
-export { Crewx } from './facade/Crewx';
-// Plugin system
-export { CrewxPlugin } from './plugin';
-// Event system
-export { TypedEventEmitter } from './events/TypedEventEmitter';
-// Layout system
-export { LayoutLoader } from './layout/loader';
-export { LayoutRenderer } from './layout/renderer';
-export { PropsValidator } from './layout/props-validator';
-export { LayoutLoadError, PropsValidationError } from './layout/types';
-// Template engine
-export { TemplateEngine } from './template/engine';
-// Document loader
-export { DocumentLoader } from './template/loader/DocumentLoader';
-export { NodeFsAdapter, defaultFsAdapter } from './platform/NodeFsAdapter';
-export { BrowserFsAdapter } from './platform/BrowserFsAdapter';
-// P1/P2 helpers (exported for direct use if needed)
-export { truncateHelper, lengthHelper, escapeHandlebarsHelper, formatFileSizeHelper, formatTimestampHelper, } from './template/helpers/p1p2';
-// Exec audit log control
-export { setAuditVerbose } from './template/helpers/exec';
-// Config utilities
-export { loadYamlFile, parseYamlContent, ConfigLoadError } from './config/loader';
-// Agent utilities
-export { resolveAgent, AgentNotFoundError } from './agent/resolver';
-// Provider utilities
-export { createProvider, ProviderError, ClientToolCallRequiredError, registerProviderFactory } from './provider/bridge';
-export { VercelProviderRuntime } from './provider/vercel-runtime';
-export { registerApiProviders } from './provider/register-api';
-// Tools
-export { createDelegateTool } from './tools/delegate';
-// Env utilities
-export { resolveCrewxCli, resolveCrewxWorkspace } from './utils/env-defaults';
-// ID utilities (backward-compat for @crewx/* built-in packages)
-export { generateId, generateFingerprint } from './utils/id';
-// Workspace utilities
-export { hashWorkspaceId, normalizeWorkspacePath } from './utils/workspace';
-// Boxing module
-export { SdkBoxService } from './boxing/box.service';
-export { buildContext } from './boxing/context-builder';
-// Parsers
-export { parseStdoutEvent } from './parsers/router';
-// Provider utilities
-export { parseUsage } from './provider/parse-usage';
-// Parallel execution
-export { ParallelRunner, ParallelRunnerTimeoutError } from './parallel/parallel-runner';
-export { runQueriesParallel, runExecutesParallel } from './parallel/helpers';
-export { AgentRuntime } from './parallel/agent-runtime';
-// Plugin provider module
-export { PluginProviderRuntime, createPluginProviderFactory } from './plugin/plugin-provider';
-// Remote agent module
-export { RemoteProviderRuntime, createRemoteProviderFactory } from './remote/remote-provider';
-export { RemoteAgentManager } from './remote/remote-agent-manager';
-export { McpHttpTransport } from './remote/remote-transport';
-// Server module (MCP handler)
-export { createHandler } from './server/handler';
-//# sourceMappingURL=index.js.map

package/dist/esm/layout/loader.js

@@ -1,268 +0,0 @@
-/**
- * LayoutLoader — loads layout templates from templates/agents/*.yaml files.
- * Ported 1:1 from packages/sdk-bak/src/services/layout-loader.service.ts.
- * Only import paths and DEFAULT_OPTIONS.templatesPath are changed.
- */
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import * as path from 'path';
-import { load as loadYaml } from 'js-yaml';
-import { LayoutLoadError, } from './types';
-/**
- * Default loader options — points to SDK's bundled templates directory.
- */
-const DEFAULT_OPTIONS = {
-    templatesPath: path.join(__dirname, '../../../templates/agents'),
-    validationMode: 'lenient',
-    fallbackLayoutId: 'crewx/default',
-};
-/**
- * Layout loader service.
- * Loads and caches layout definitions from YAML files.
- * Provides fallback mechanism and prop override support.
- */
-export class LayoutLoader {
-    layouts = new Map();
-    options;
-    constructor(options) {
-        this.options = { ...DEFAULT_OPTIONS, ...options };
-        this.loadAllLayouts();
-    }
-    /**
-     * Load a layout by ID with optional props override.
-     */
-    load(layoutId, propsOverride) {
-        let layout = this.layouts.get(layoutId);
-        if (!layout) {
-            const normalizedId = this.normalizeLayoutId(layoutId);
-            layout = this.layouts.get(normalizedId);
-        }
-        if (!layout) {
-            console.warn(`Layout not found: ${layoutId}, falling back to ${this.options.fallbackLayoutId}`);
-            layout = this.layouts.get(this.options.fallbackLayoutId);
-            if (!layout) {
-                throw new LayoutLoadError(`Fallback layout not found: ${this.options.fallbackLayoutId}`, this.options.fallbackLayoutId);
-            }
-        }
-        if (propsOverride && Object.keys(propsOverride).length > 0) {
-            return {
-                ...layout,
-                defaultProps: { ...layout.defaultProps, ...propsOverride },
-            };
-        }
-        return layout;
-    }
-    getLayoutIds() {
-        return Array.from(this.layouts.keys());
-    }
-    hasLayout(layoutId) {
-        if (this.layouts.has(layoutId))
-            return true;
-        const normalizedId = this.normalizeLayoutId(layoutId);
-        return this.layouts.has(normalizedId);
-    }
-    reload() {
-        this.layouts.clear();
-        this.loadAllLayouts();
-    }
-    /**
-     * Register or override a layout at runtime.
-     */
-    registerLayout(layoutId, layoutConfig) {
-        if (!layoutId || typeof layoutId !== 'string') {
-            throw new LayoutLoadError('Layout ID must be a non-empty string', layoutId);
-        }
-        const config = typeof layoutConfig === 'string'
-            ? { template: layoutConfig }
-            : layoutConfig;
-        const template = typeof config.template === 'string' ? config.template : '';
-        if (!template || template.trim().length === 0) {
-            throw new LayoutLoadError(`Custom layout template is empty for ${layoutId}`, layoutId);
-        }
-        const propsSchemaRaw = config.propsSchema || {};
-        const defaultPropsFromSchema = this.extractDefaultProps(propsSchemaRaw);
-        const explicitDefaults = config.defaultProps || {};
-        const layoutDefinition = {
-            id: layoutId,
-            version: config.version || '1.0.0',
-            description: config.description || `Custom layout ${layoutId}`,
-            template,
-            propsSchema: this.parsePropsSchema(propsSchemaRaw),
-            defaultProps: { ...defaultPropsFromSchema, ...explicitDefaults },
-        };
-        const existingLayout = this.layouts.get(layoutId);
-        const templatesEqual = existingLayout?.template === template &&
-            JSON.stringify(existingLayout?.defaultProps ?? {}) === JSON.stringify(layoutDefinition.defaultProps ?? {}) &&
-            JSON.stringify(existingLayout?.propsSchema ?? {}) === JSON.stringify(layoutDefinition.propsSchema ?? {});
-        this.layouts.set(layoutId, layoutDefinition);
-        if (process.env.CREWX_VERBOSE === '1') {
-            if (!existingLayout) {
-                console.error(`Registered custom layout: ${layoutId}`);
-            }
-            else if (!templatesEqual) {
-                console.error(`Updated custom layout: ${layoutId}`);
-            }
-        }
-    }
-    /**
-     * Register multiple layouts from a map.
-     */
-    registerLayouts(layoutsMap) {
-        for (const [id, config] of Object.entries(layoutsMap)) {
-            try {
-                this.registerLayout(id, config);
-            }
-            catch (error) {
-                console.warn(`Failed to register custom layout ${id}:`, error instanceof Error ? error.message : error);
-            }
-        }
-    }
-    loadAllLayouts() {
-        const layoutsDir = this.options.templatesPath;
-        if (!existsSync(layoutsDir)) {
-            throw new LayoutLoadError(`Templates directory not found: ${layoutsDir}`, undefined, new Error(`Directory does not exist: ${layoutsDir}`));
-        }
-        try {
-            const files = readdirSync(layoutsDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
-            if (files.length === 0) {
-                console.warn(`No layout files found in ${layoutsDir}`);
-            }
-            for (const file of files) {
-                const layoutName = file.replace(/\.(yaml|yml)$/, '');
-                const layoutPath = path.join(layoutsDir, file);
-                try {
-                    const layout = this.loadLayoutFile(layoutPath, layoutName);
-                    const layoutId = `crewx/${layoutName}`;
-                    this.layouts.set(layoutId, layout);
-                    if (layoutId !== 'crewx/minimal') {
-                        if (process.env.CREWX_VERBOSE === '1')
-                            console.error(`Loaded layout: ${layoutId} from ${file}`);
-                    }
-                }
-                catch (error) {
-                    console.error(`Failed to load layout file ${file}:`, error);
-                }
-            }
-            if (process.env.CREWX_VERBOSE === '1')
-                console.error(`Loaded ${this.layouts.size} layouts from ${layoutsDir}`);
-        }
-        catch (error) {
-            throw new LayoutLoadError(`Failed to read layouts directory: ${layoutsDir}`, undefined, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    loadLayoutFile(filePath, layoutName) {
-        try {
-            const content = readFileSync(filePath, 'utf-8');
-            if (!content || content.trim().length === 0) {
-                console.warn(`Empty YAML file: ${filePath}, will use fallback`);
-                throw new LayoutLoadError(`Empty YAML file: ${filePath}`, layoutName, new Error('File content is empty'));
-            }
-            const parsed = loadYaml(content);
-            if (!parsed || typeof parsed !== 'object') {
-                console.warn(`Invalid YAML content in ${filePath} (parsed as ${typeof parsed}), will use fallback`);
-                throw new LayoutLoadError(`Invalid or empty YAML in ${filePath}`, layoutName, new Error('YAML parsing returned null/undefined or non-object'));
-            }
-            // Format 2: layouts map (templates/agents/default.yaml format)
-            if (parsed.layouts && typeof parsed.layouts === 'object') {
-                const entry = this.resolveLayoutEntry(parsed.layouts, layoutName);
-                if (!entry || entry.template.trim().length === 0) {
-                    console.warn(`Empty or missing layout template in ${filePath} for ${layoutName}`);
-                    throw new LayoutLoadError(`Layout template not found or empty in layouts map: ${layoutName}`, layoutName);
-                }
-                // propsSchema may be inline in the layout entry object (e.g. default.yaml) or at the top level
-                const propsSchemaRaw = entry.propsSchema || parsed.propsSchema || {};
-                return {
-                    id: `crewx/${layoutName}`,
-                    version: parsed.version || '1.0.0',
-                    description: parsed.description || `CrewX ${layoutName} layout`,
-                    template: entry.template,
-                    propsSchema: this.parsePropsSchema(propsSchemaRaw),
-                    defaultProps: this.extractDefaultProps(propsSchemaRaw),
-                };
-            }
-            else {
-                // Format 1: direct layout definition
-                if (!parsed.template || (typeof parsed.template === 'string' && parsed.template.trim().length === 0)) {
-                    console.warn(`Empty or missing template field in ${filePath}`);
-                    throw new LayoutLoadError(`Layout template is missing or empty in ${filePath}`, layoutName);
-                }
-                return {
-                    id: parsed.id || `crewx/${layoutName}`,
-                    version: parsed.version || '1.0.0',
-                    description: parsed.description || '',
-                    template: parsed.template,
-                    propsSchema: this.parsePropsSchema(parsed.propsSchema || {}),
-                    defaultProps: this.extractDefaultProps(parsed.propsSchema || {}),
-                };
-            }
-        }
-        catch (error) {
-            throw new LayoutLoadError(`Failed to load layout file: ${filePath}`, layoutName, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    parsePropsSchema(raw) {
-        const schema = {};
-        for (const [key, value] of Object.entries(raw)) {
-            if (typeof value === 'object' && value !== null) {
-                schema[key] = value;
-            }
-        }
-        return schema;
-    }
-    extractDefaultProps(propsSchema) {
-        const defaults = {};
-        for (const [key, schema] of Object.entries(propsSchema)) {
-            if (schema && typeof schema === 'object') {
-                if ('defaultValue' in schema) {
-                    defaults[key] = schema.defaultValue;
-                }
-                else if ('default' in schema) {
-                    defaults[key] = schema.default;
-                }
-            }
-        }
-        return defaults;
-    }
-    normalizeLayoutId(layoutId) {
-        if (!layoutId)
-            return this.options.fallbackLayoutId;
-        if (layoutId.includes('/'))
-            return layoutId;
-        return `crewx/${layoutId}`;
-    }
-    resolveLayoutEntry(layoutsMap, layoutName) {
-        const candidates = new Set();
-        if (layoutName) {
-            candidates.add(layoutName);
-            if (layoutName.includes('/')) {
-                const parts = layoutName.split('/');
-                const last = parts[parts.length - 1];
-                if (last)
-                    candidates.add(last);
-            }
-            else {
-                candidates.add(`crewx/${layoutName}`);
-            }
-        }
-        candidates.add('default');
-        for (const key of candidates) {
-            const value = layoutsMap[key];
-            if (typeof value === 'string' && value.trim().length > 0) {
-                return { template: value };
-            }
-            if (value && typeof value === 'object' && typeof value.template === 'string' && value.template.trim().length > 0) {
-                return { template: value.template, propsSchema: value.propsSchema };
-            }
-        }
-        for (const value of Object.values(layoutsMap)) {
-            if (typeof value === 'string' && value.trim().length > 0) {
-                return { template: value };
-            }
-            const v = value;
-            if (v && typeof v === 'object' && typeof v.template === 'string' && v.template.trim().length > 0) {
-                return { template: v.template, propsSchema: v.propsSchema };
-            }
-        }
-        return undefined;
-    }
-}
-//# sourceMappingURL=loader.js.map