@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/esm/hooks/define.js

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,15 @@
+/**
+ * @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

@@ -0,0 +1,60 @@
+/**
+ * @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

@@ -0,0 +1,268 @@
+/**
+ * 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