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

package/dist/esm/parsers/gemini.parser.js

@@ -0,0 +1,43 @@
+import { isAgentCallCommand, parseAgentCall } from './agent-call.util';
+/**
+ * Parse Gemini stream-json events into TaskLogEntry[].
+ *
+ * Gemini events:
+ * - { type: "message", role: "assistant", delta: true, content: "..." }
+ * - { type: "init", ... } (ignored)
+ * - { type: "tool_use", tool_name, tool_id, parameters }
+ * - { type: "tool_result", tool_id, status, output }
+ */
+export function parseGeminiEvent(timestamp, parsed) {
+    const type = parsed.type;
+    if (type === 'message') {
+        const role = parsed.role;
+        if (role !== 'assistant')
+            return [];
+        const content = parsed.content;
+        if (!content)
+            return [];
+        return [{ timestamp, type: 'text', content }];
+    }
+    if (type === 'tool_use') {
+        const toolName = String(parsed.tool_name || '');
+        const toolUseId = parsed.tool_id;
+        const parameters = parsed.parameters;
+        const inputStr = parameters?.command
+            ? String(parameters.command)
+            : JSON.stringify(parameters || {});
+        if (/^bash$/i.test(toolName) && isAgentCallCommand(inputStr)) {
+            return [parseAgentCall(timestamp, inputStr)];
+        }
+        return [{ timestamp, type: 'tool_use', toolName, toolUseId, toolInput: inputStr }];
+    }
+    if (type === 'tool_result') {
+        const toolUseId = parsed.tool_id;
+        const output = String(parsed.output || '');
+        const isError = parsed.status !== 'success';
+        return [{ timestamp, type: 'tool_result', toolUseId, resultPreview: output, isError }];
+    }
+    // init and other events: skip
+    return [];
+}
+//# sourceMappingURL=gemini.parser.js.map

package/dist/esm/parsers/opencode.parser.js

@@ -0,0 +1,73 @@
+/**
+ * Parse OpenCode stream-json events (--format json) into TaskLogEntry[].
+ *
+ * OpenCode events:
+ * - { type: "step_start", sessionID: "ses_...", part: { type: "step-start" } }
+ * - { type: "text", part: { type: "text", text: "..." } }
+ * - { type: "step_finish", part: { reason: "stop", tokens: { total, input, output, reasoning, cache: { write, read } }, cost: 0 } }
+ * - { type: "tool_use", part: { type: "tool", tool: "bash"|"write"|..., callID: "...", state: { status, input, output } } }
+ */
+export function parseOpencodeEvent(timestamp, parsed) {
+    const type = parsed.type;
+    if (type === 'text') {
+        const part = parsed.part;
+        const text = part?.text;
+        if (!text)
+            return [];
+        return [{ timestamp, type: 'text', content: text }];
+    }
+    if (type === 'tool_use') {
+        const part = parsed.part;
+        if (!part)
+            return [];
+        const tool = String(part.tool || '');
+        const toolUseId = String(part.callID || '');
+        const state = part.state;
+        const status = String(state?.status || '');
+        const input = state?.input;
+        const inputStr = extractToolInput(input);
+        const entries = [
+            { timestamp, type: 'tool_use', toolName: tool, toolUseId, toolInput: inputStr },
+        ];
+        if (status === 'completed' && state?.output !== undefined) {
+            const output = state.output;
+            const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+            entries.push({ timestamp, type: 'tool_result', toolUseId, resultPreview: outputStr, isError: false });
+        }
+        else if (status === 'error') {
+            entries.push({
+                timestamp,
+                type: 'tool_result',
+                toolUseId,
+                resultPreview: String(state?.error || 'tool error'),
+                isError: true,
+            });
+        }
+        return entries;
+    }
+    // step_start, step_finish: skip (usage is extracted by parse-usage.ts)
+    return [];
+}
+/**
+ * Extract a human-friendly string from OpenCode tool input.
+ *
+ * Matches Claude/Gemini parser behaviour:
+ *  - bash-like  → input.command   ("mkdir -p /tmp/foo")
+ *  - file tools → input.filePath  ("/tmp/foo/bar.ts")
+ *  - otherwise  → JSON.stringify fallback
+ */
+function extractToolInput(input) {
+    if (typeof input === 'string')
+        return input;
+    if (!input || typeof input !== 'object')
+        return JSON.stringify(input ?? {});
+    const obj = input;
+    if (obj.command)
+        return String(obj.command);
+    if (obj.filePath)
+        return String(obj.filePath);
+    if (obj.pattern)
+        return String(obj.pattern);
+    return JSON.stringify(obj);
+}
+//# sourceMappingURL=opencode.parser.js.map

package/dist/esm/parsers/router.js

@@ -0,0 +1,53 @@
+/**
+ * parseStdoutEvent — routes a single stdout JSONL event to the appropriate provider parser.
+ * Returns TaskLogEntry[] (may be empty if event is not recognized or irrelevant).
+ */
+import { parseClaudeEvent } from './claude.parser';
+import { parseCopilotEvent } from './copilot.parser';
+import { parseCodexEvent } from './codex.parser';
+import { parseGeminiEvent } from './gemini.parser';
+import { parseOpencodeEvent } from './opencode.parser';
+export function parseStdoutEvent(timestamp, message) {
+    let parsed;
+    try {
+        parsed = JSON.parse(message);
+    }
+    catch {
+        return [];
+    }
+    const type = parsed.type;
+    if (!type)
+        return [];
+    // Claude stream-json (system event excluded — meta event)
+    if (type === 'assistant' || type === 'user') {
+        return parseClaudeEvent(timestamp, parsed);
+    }
+    // Copilot json — assistant.* check must precede Gemini "message" check
+    if (type.startsWith('tool.execution') || type.startsWith('assistant.') || type === 'user.message') {
+        return parseCopilotEvent(timestamp, parsed);
+    }
+    // Codex experimental-json
+    if (type.startsWith('item.') || type.startsWith('turn.') || type.startsWith('thread.')) {
+        return parseCodexEvent(timestamp, parsed);
+    }
+    // Gemini stream-json — tool_use/tool_result routed by structure below
+    if (type === 'message' || type === 'init') {
+        return parseGeminiEvent(timestamp, parsed);
+    }
+    // tool_use / tool_result: disambiguate by schema structure.
+    // OpenCode has a `part` object; Gemini is flat (tool_name, parameters).
+    if (type === 'tool_use' || type === 'tool_result') {
+        if (parsed.part && typeof parsed.part === 'object') {
+            return parseOpencodeEvent(timestamp, parsed);
+        }
+        return parseGeminiEvent(timestamp, parsed);
+    }
+    // OpenCode stream-json (--format json)
+    // Note: 'text' is a generic name but not used by any other provider currently.
+    // 'step_start' and 'step_finish' are OpenCode-specific.
+    if (type === 'text' || type === 'step_start' || type === 'step_finish') {
+        return parseOpencodeEvent(timestamp, parsed);
+    }
+    return [];
+}
+//# sourceMappingURL=router.js.map

package/dist/esm/platform/BrowserFsAdapter.js

@@ -0,0 +1,80 @@
+/**
+ * BrowserFsAdapter — IFsAdapter implementation for browser environments.
+ *
+ * Uses localStorage as the backing store with a key-prefix namespace.
+ * Paths are normalized to forward-slash POSIX style.
+ *
+ * Usage:
+ *   const fs = new BrowserFsAdapter();
+ *   // Pre-load content before using with DocumentLoader:
+ *   fs.setItem('/docs/guide.md', '# Guide\n...');
+ */
+const DEFAULT_PREFIX = 'crewx:fs:';
+export class BrowserFsAdapter {
+    prefix;
+    store;
+    /**
+     * @param options.prefix - localStorage key prefix (default: 'crewx:fs:')
+     * @param options.storage - optional external storage map (defaults to an in-memory Map;
+     *                          pass a localStorage-backed wrapper for persistence)
+     */
+    constructor(options) {
+        this.prefix = options?.prefix ?? DEFAULT_PREFIX;
+        this.store = options?.storage ?? new Map();
+    }
+    async readFile(path) {
+        const key = this.toKey(path);
+        const content = this.store.get(key);
+        if (content === undefined) {
+            throw new Error(`BrowserFsAdapter: file not found: ${path}`);
+        }
+        return content;
+    }
+    async exists(path) {
+        return this.store.has(this.toKey(path));
+    }
+    resolvePath(...segments) {
+        // Simple POSIX-style path joining (no true "resolve" since there's no cwd)
+        const joined = segments
+            .map(s => s.replace(/\\/g, '/'))
+            .join('/')
+            .replace(/\/+/g, '/');
+        // Normalize . and .. segments
+        const parts = joined.split('/');
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '.' || part === '')
+                continue;
+            if (part === '..') {
+                resolved.pop();
+            }
+            else {
+                resolved.push(part);
+            }
+        }
+        const result = resolved.join('/');
+        return joined.startsWith('/') ? `/${result}` : result;
+    }
+    isAbsolute(path) {
+        return path.startsWith('/');
+    }
+    // ── Browser-specific helpers ───────────────────────────────────────────────
+    /** Store a virtual file for later reading. */
+    setItem(path, content) {
+        this.store.set(this.toKey(path), content);
+    }
+    /** Remove a virtual file. */
+    removeItem(path) {
+        this.store.delete(this.toKey(path));
+    }
+    /** List all stored virtual file paths. */
+    keys() {
+        return Array.from(this.store.keys())
+            .filter(k => k.startsWith(this.prefix))
+            .map(k => k.slice(this.prefix.length));
+    }
+    toKey(path) {
+        return `${this.prefix}${path.replace(/\\/g, '/')}`;
+    }
+}
+//# sourceMappingURL=BrowserFsAdapter.js.map

package/dist/esm/platform/IFsAdapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IFsAdapter.js.map

package/dist/esm/platform/NodeFsAdapter.js

@@ -0,0 +1,34 @@
+/**
+ * NodeFsAdapter — default IFsAdapter implementation using Node.js fs/path.
+ *
+ * This is the concrete adapter used in CLI and server contexts.
+ * Full platform abstraction (WEB, browser) is deferred to a future round.
+ */
+import { readFile, access } from 'fs/promises';
+import { resolve, join, isAbsolute } from 'path';
+export class NodeFsAdapter {
+    async readFile(path) {
+        return readFile(path, 'utf-8');
+    }
+    async exists(path) {
+        try {
+            await access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    resolvePath(...segments) {
+        if (segments.length === 1) {
+            return resolve(segments[0]);
+        }
+        return resolve(join(...segments));
+    }
+    isAbsolute(path) {
+        return isAbsolute(path);
+    }
+}
+/** Singleton default adapter for convenience in CLI usage. */
+export const defaultFsAdapter = new NodeFsAdapter();
+//# sourceMappingURL=NodeFsAdapter.js.map

package/dist/esm/plugin/plugin-provider.js

@@ -0,0 +1,202 @@
+/**
+ * Plugin Provider Runtime
+ *
+ * Implements ProviderRuntime for `type: plugin` providers in crewx.yaml.
+ * Wraps an arbitrary CLI tool as a CrewX agent via child_process.spawn (shell: false).
+ *
+ * Symmetric to remote/remote-provider.ts — registered as the `plugin` namespace factory.
+ */
+import { spawn } from 'child_process';
+import { ProviderError } from '../provider/bridge.js';
+/**
+ * ProviderRuntime implementation for plugin (CLI-wrapped) providers.
+ *
+ * Created by the `plugin` namespace factory when `createProvider('plugin/mock')` is called.
+ * Spawns the configured CLI with args derived from query_args/execute_args,
+ * applies `{model}` substitution, and routes the prompt via args or stdin.
+ */
+export class PluginProviderRuntime {
+    config;
+    providerStr;
+    constructor(id, config) {
+        this.config = config;
+        this.providerStr = `plugin/${id}`;
+        // Validate at construction time (fail early, not at call time)
+        validateCliCommand(config.cli_command);
+        validateCliArgs(config.query_args);
+        validateCliArgs(config.execute_args);
+        if (config.error_patterns)
+            validateErrorPatterns(config.error_patterns);
+        if (config.env)
+            validateEnv(config.env);
+    }
+    async query(message, options) {
+        const model = options?.model ?? this.config.default_model ?? 'default';
+        const args = resolveArgs(this.config.query_args, model, message, this.config.prompt_in_args);
+        const stdinMessage = this.config.prompt_in_args ? undefined : message;
+        options?.onCommand?.(`${this.config.cli_command} ${args.join(' ')}`);
+        const timeoutMs = this.config.timeout?.query ?? 600000;
+        return this.runProcess(args, options, stdinMessage, timeoutMs);
+    }
+    async execute(message, options) {
+        const model = options?.model ?? this.config.default_model ?? 'default';
+        const args = resolveArgs(this.config.execute_args, model, message, this.config.prompt_in_args);
+        const stdinMessage = this.config.prompt_in_args ? undefined : message;
+        options?.onCommand?.(`${this.config.cli_command} ${args.join(' ')}`);
+        const timeoutMs = this.config.timeout?.execute ?? 600000;
+        return this.runProcess(args, options, stdinMessage, timeoutMs);
+    }
+    runProcess(args, options, stdinMessage, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            // Merge env: process.env is the base; config.env values are added on top.
+            // Never replaces process.env — only extends it.
+            const mergedEnv = {
+                ...process.env,
+                ...(this.config.env ?? {}),
+            };
+            const proc = spawn(this.config.cli_command, args, {
+                env: mergedEnv,
+                shell: false, // Security: no shell interpolation
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            // Write prompt to stdin when prompt_in_args is false
+            if (stdinMessage !== undefined) {
+                proc.stdin.write(stdinMessage);
+                proc.stdin.end();
+            }
+            else {
+                proc.stdin.end();
+            }
+            if (proc.pid !== undefined) {
+                options?.onPid?.(proc.pid);
+            }
+            let stdout = '';
+            let stderr = '';
+            let stdoutBuf = '';
+            let stderrBuf = '';
+            proc.stdout.on('data', (chunk) => {
+                const str = chunk.toString();
+                stdout += str;
+                stdoutBuf += str;
+                const lines = stdoutBuf.split('\n');
+                stdoutBuf = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (line.trim())
+                        options?.onOutput?.(line, 'stdout');
+                }
+            });
+            proc.stderr.on('data', (chunk) => {
+                const str = chunk.toString();
+                stderr += str;
+                stderrBuf += str;
+                const lines = stderrBuf.split('\n');
+                stderrBuf = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (line.trim())
+                        options?.onOutput?.(line, 'stderr');
+                }
+            });
+            // Hard timeout — terminate and reject if exceeded
+            const timeoutHandle = setTimeout(() => {
+                proc.kill('SIGTERM');
+                reject(new ProviderError(`Plugin provider "${this.providerStr}" timed out after ${timeoutMs}ms`, this.providerStr));
+            }, timeoutMs);
+            proc.on('error', (err) => {
+                clearTimeout(timeoutHandle);
+                if (err.code === 'ENOENT') {
+                    const hint = this.config.not_installed_message
+                        ?? `CLI command "${this.config.cli_command}" not found. Is ${this.config.id} installed?`;
+                    reject(new ProviderError(hint, this.providerStr));
+                }
+                else {
+                    reject(new ProviderError(`Spawn error: ${err.message}`, this.providerStr));
+                }
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeoutHandle);
+                // Flush residual buffered content (no trailing newline)
+                if (stdoutBuf.trim())
+                    options?.onOutput?.(stdoutBuf, 'stdout');
+                if (stderrBuf.trim())
+                    options?.onOutput?.(stderrBuf, 'stderr');
+                const exitCode = code ?? 0;
+                options?.onExitCode?.(exitCode);
+                // Check configured error patterns before exit code
+                if (this.config.error_patterns) {
+                    const combined = stderr || stdout;
+                    for (const ep of this.config.error_patterns) {
+                        if (combined.includes(ep.pattern)) {
+                            reject(new ProviderError(ep.message, this.providerStr));
+                            return;
+                        }
+                    }
+                }
+                if (code !== 0) {
+                    reject(new ProviderError(`Process exited with code ${code}: ${stderr.slice(0, 500)}`, this.providerStr));
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+}
+// ── Factory ─────────────────────────────────────────────────────────────────
+/**
+ * Create a provider factory function for the `plugin` namespace.
+ *
+ * @param pluginConfigs - Map of plugin provider ID → config (from crewx.yaml `providers:` section)
+ * @returns ProviderFactory to register via registerProviderFactory('plugin', factory)
+ */
+export function createPluginProviderFactory(pluginConfigs) {
+    return (id, _providerStr) => {
+        const config = pluginConfigs.get(id);
+        if (!config) {
+            throw new ProviderError(`Plugin provider "${id}" not found. Available: ${Array.from(pluginConfigs.keys()).join(', ') || '(none)'}`, `plugin/${id}`);
+        }
+        return new PluginProviderRuntime(id, config);
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Build the final args array for a CLI invocation:
+ * 1. Replace `{model}` placeholders in each arg.
+ * 2. If promptInArgs is true, append the prompt as a positional argument.
+ */
+function resolveArgs(templateArgs, model, prompt, promptInArgs) {
+    const args = templateArgs.map(arg => arg.replace(/\{model\}/g, model));
+    if (promptInArgs) {
+        args.push(prompt);
+    }
+    return args;
+}
+// ── Validation ───────────────────────────────────────────────────────────────
+function validateCliCommand(cliCommand) {
+    if (!cliCommand || typeof cliCommand !== 'string') {
+        throw new Error('Plugin provider requires a cli_command');
+    }
+}
+function validateCliArgs(args) {
+    if (!Array.isArray(args)) {
+        throw new Error('CLI arguments must be an array');
+    }
+    for (const arg of args) {
+        if (typeof arg !== 'string') {
+            throw new Error('Each CLI argument must be a string');
+        }
+    }
+}
+function validateErrorPatterns(patterns) {
+    for (const { pattern } of patterns) {
+        if (typeof pattern !== 'string') {
+            throw new Error('Error pattern must be a string');
+        }
+    }
+}
+function validateEnv(env) {
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            throw new Error('env entries must be string key/value pairs');
+        }
+    }
+}
+//# sourceMappingURL=plugin-provider.js.map

package/dist/esm/plugin/types.js

@@ -0,0 +1,8 @@
+/**
+ * Plugin Provider Types
+ *
+ * Configuration for `type: plugin` providers in crewx.yaml.
+ * Plugin providers wrap arbitrary CLI tools as CrewX agents.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/plugin.js

@@ -0,0 +1,25 @@
+/**
+ * CrewxPlugin — base class for SDK plugins.
+ *
+ * Plugins subscribe to Crewx events in attach() and clean up in detach().
+ * Register via Crewx.use(plugin).
+ *
+ * @example
+ * class MyPlugin extends CrewxPlugin {
+ *   readonly name = 'my-plugin';
+ *   attach(crewx: Crewx) {
+ *     crewx.on('task:start', (e) => console.log(e.traceId));
+ *   }
+ * }
+ * await crewx.use(new MyPlugin());
+ */
+export class CrewxPlugin {
+    /**
+     * Called on Crewx.close() in LIFO order.
+     * Remove event listeners and release resources here.
+     * Default: no-op.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    detach(_crewx) { }
+}
+//# sourceMappingURL=plugin.js.map

package/dist/esm/provider/bridge.browser.js

@@ -0,0 +1,43 @@
+/**
+ * Browser-safe provider bridge.
+ * Registry pattern only — no child_process / CLI spawn.
+ */
+export class ProviderError extends Error {
+    providerStr;
+    constructor(message, providerStr) {
+        super(message);
+        this.providerStr = providerStr;
+        this.name = 'ProviderError';
+    }
+}
+// ── Provider factory registry ───────────────────────────────────────────────
+const _providerFactories = new Map();
+/**
+ * Register a provider factory for a given namespace.
+ *
+ * @example
+ * registerProviderFactory('api', (id, providerStr) => ({
+ *   async query(message, options) { ... },
+ *   async execute(message, options) { ... },
+ * }));
+ */
+export function registerProviderFactory(namespace, factory) {
+    _providerFactories.set(namespace, factory);
+}
+/**
+ * Create a provider runtime for the given provider string.
+ * Browser version — only supports registered factories (no CLI fallback).
+ */
+export function createProvider(providerStr) {
+    const parts = providerStr.split('/');
+    if (parts.length !== 2) {
+        throw new ProviderError(`Invalid provider format: "${providerStr}". Expected namespace/id (e.g., api/webllm)`, providerStr);
+    }
+    const [namespace, id] = parts;
+    const factory = _providerFactories.get(namespace);
+    if (factory) {
+        return factory(id, providerStr);
+    }
+    throw new ProviderError(`Unsupported provider namespace: "${namespace}". Register a factory with registerProviderFactory('${namespace}', factory).`, providerStr);
+}
+//# sourceMappingURL=bridge.browser.js.map