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

package/dist/plugins/conversation.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationPlugin = void 0;
+const plugin_1 = require("../plugin");
+const sqlite_provider_1 = require("../conversation/sqlite-provider");
+class ConversationPlugin extends plugin_1.CrewxPlugin {
+    name = 'conversation';
+    _provider;
+    unsubStart = null;
+    unsubEnd = null;
+    constructor(opts) {
+        super();
+        this._provider = new sqlite_provider_1.SqliteConversationProvider(opts?.dbPath);
+    }
+    /** Expose provider for SDK history auto-fetch (WI-CONV-002). */
+    get conversationProvider() {
+        return this._provider;
+    }
+    attach(crewx) {
+        // task:start — save user message + ensure thread
+        this.unsubStart = crewx.on('task:start', async (event) => {
+            if (!event.threadId)
+                return;
+            const platform = (event.platform ?? 'cli');
+            try {
+                await this._provider.ensureThread(event.threadId, platform, event.workspaceId);
+                await this._provider.saveUserMessage(event.threadId, event.message ?? '');
+            }
+            catch {
+                // Non-fatal: conversation persistence must never crash the main process
+            }
+        });
+        // task:end — save assistant response (WI-CONV-002)
+        this.unsubEnd = crewx.on('task:end', async (event) => {
+            if (!event.result)
+                return;
+            // Resolve threadId from metadata propagated in task:start
+            const threadId = event.metadata?.threadId;
+            if (!threadId)
+                return;
+            const agentId = event.agentRef?.replace(/^@/, '') ?? '';
+            try {
+                await this._provider.saveAssistantMessage(threadId, event.result, agentId);
+            }
+            catch {
+                // Non-fatal: conversation persistence must never crash the main process
+            }
+        });
+    }
+    detach(_crewx) {
+        this.unsubStart?.();
+        this.unsubStart = null;
+        this.unsubEnd?.();
+        this.unsubEnd = null;
+        this._provider.close?.();
+    }
+}
+exports.ConversationPlugin = ConversationPlugin;
+//# sourceMappingURL=conversation.js.map

package/dist/plugins/file-logger.d.ts

@@ -0,0 +1,29 @@
+/**
+ * FileLoggerPlugin — writes structured log files to .crewx/logs/.
+ *
+ * Subscribes to task:start and task:end events and writes one log file
+ * per task execution. Format mirrors cli-bak TaskManagementService for
+ * backward compatibility.
+ *
+ * File name: {YYYYMMDDTHHmmss}_{traceId}.log
+ * e.g. 20260412T145044_tsk_AbCdEfGh.log
+ */
+import { CrewxPlugin } from '../plugin';
+import type { Crewx } from '../facade/Crewx';
+export interface FileLoggerPluginOptions {
+    /** Root directory under which `.crewx/logs/` will be created. Defaults to `process.cwd()`. */
+    workspaceRoot?: string;
+    /** Caller-provided version string written into the log header. Defaults to `'unknown'`. */
+    version?: string;
+}
+export declare class FileLoggerPlugin extends CrewxPlugin {
+    readonly name = "file-logger";
+    private unsubs;
+    private logFiles;
+    private readonly logsDir;
+    private readonly version;
+    constructor(opts?: FileLoggerPluginOptions);
+    attach(crewx: Crewx): void;
+    detach(_crewx: Crewx): void;
+}
+//# sourceMappingURL=file-logger.d.ts.map

package/dist/plugins/file-logger.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * FileLoggerPlugin — writes structured log files to .crewx/logs/.
+ *
+ * Subscribes to task:start and task:end events and writes one log file
+ * per task execution. Format mirrors cli-bak TaskManagementService for
+ * backward compatibility.
+ *
+ * File name: {YYYYMMDDTHHmmss}_{traceId}.log
+ * e.g. 20260412T145044_tsk_AbCdEfGh.log
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLoggerPlugin = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const plugin_1 = require("../plugin");
+const timestamp_1 = require("../utils/timestamp");
+class FileLoggerPlugin extends plugin_1.CrewxPlugin {
+    name = 'file-logger';
+    unsubs = [];
+    logFiles = new Map();
+    logsDir;
+    version;
+    constructor(opts) {
+        super();
+        this.logsDir = (0, path_1.join)(opts?.workspaceRoot ?? process.cwd(), '.crewx', 'logs');
+        this.version = opts?.version ?? 'unknown';
+    }
+    attach(crewx) {
+        this.unsubs.push(crewx.on('task:start', (event) => {
+            try {
+                if (!(0, fs_1.existsSync)(this.logsDir)) {
+                    (0, fs_1.mkdirSync)(this.logsDir, { recursive: true });
+                }
+                const ts = (0, timestamp_1.formatTimestamp)(event.timestamp);
+                const logFile = (0, path_1.join)(this.logsDir, `${ts}_${event.traceId}.log`);
+                this.logFiles.set(event.traceId, logFile);
+                const header = `=== TASK LOG: ${event.traceId} ===\n` +
+                    `CrewX Version: ${this.version}\n` +
+                    `Mode: ${event.mode}\n` +
+                    `Agent: ${event.agentRef}\n` +
+                    `Started: ${event.timestamp.toLocaleString()}\n` +
+                    `Message: ${event.message}\n` +
+                    `\n`;
+                (0, fs_1.writeFileSync)(logFile, header, { encoding: 'utf8', mode: 0o600 });
+            }
+            catch {
+                // Non-fatal: logging must never crash the main process
+            }
+        }), crewx.on('task:output', (event) => {
+            try {
+                const logFile = this.logFiles.get(event.traceId);
+                if (!logFile)
+                    return;
+                const ts = new Date().toISOString();
+                (0, fs_1.appendFileSync)(logFile, `[${ts}] STDOUT: ${event.output}\n`, 'utf8');
+            }
+            catch {
+                // Non-fatal
+            }
+        }), crewx.on('task:end', (event) => {
+            try {
+                const logFile = this.logFiles.get(event.traceId);
+                if (!logFile)
+                    return;
+                const ts = new Date().toLocaleString();
+                const status = event.error
+                    ? `failed: ${event.error.message}`
+                    : 'completed successfully';
+                const completion = `[${ts}] INFO: Task ${status} in ${event.durationMs}ms\n` +
+                    `[${ts}] INFO: Process closed with exit code: ${event.error ? 1 : 0}\n`;
+                (0, fs_1.appendFileSync)(logFile, completion, 'utf8');
+                this.logFiles.delete(event.traceId);
+            }
+            catch {
+                // Non-fatal
+            }
+        }));
+    }
+    detach(_crewx) {
+        this.unsubs.forEach(fn => fn());
+        this.unsubs = [];
+        this.logFiles.clear();
+    }
+}
+exports.FileLoggerPlugin = FileLoggerPlugin;
+//# sourceMappingURL=file-logger.js.map

package/dist/plugins/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @crewx/sdk/plugins — Optional plugins for advanced runtime features.
+ *
+ * These plugins depend on Node.js APIs (fs, path, sqlite) and are kept out
+ * of the main `@crewx/sdk` entry to avoid bundling them into browser builds.
+ * Consumers must explicitly import from this subpath:
+ *
+ *   import { FileLoggerPlugin, SqliteTracingPlugin } from '@crewx/sdk/plugins';
+ */
+export { FileLoggerPlugin } from './file-logger';
+export type { FileLoggerPluginOptions } from './file-logger';
+export { SqliteTracingPlugin } from './sqlite-tracing';
+export type { SqliteTracingPluginOptions } from './sqlite-tracing';
+export { ConversationPlugin } from './conversation';
+export type { ConversationPluginOptions } from './conversation';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @crewx/sdk/plugins — Optional plugins for advanced runtime features.
+ *
+ * These plugins depend on Node.js APIs (fs, path, sqlite) and are kept out
+ * of the main `@crewx/sdk` entry to avoid bundling them into browser builds.
+ * Consumers must explicitly import from this subpath:
+ *
+ *   import { FileLoggerPlugin, SqliteTracingPlugin } from '@crewx/sdk/plugins';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationPlugin = exports.SqliteTracingPlugin = exports.FileLoggerPlugin = void 0;
+var file_logger_1 = require("./file-logger");
+Object.defineProperty(exports, "FileLoggerPlugin", { enumerable: true, get: function () { return file_logger_1.FileLoggerPlugin; } });
+var sqlite_tracing_1 = require("./sqlite-tracing");
+Object.defineProperty(exports, "SqliteTracingPlugin", { enumerable: true, get: function () { return sqlite_tracing_1.SqliteTracingPlugin; } });
+var conversation_1 = require("./conversation");
+Object.defineProperty(exports, "ConversationPlugin", { enumerable: true, get: function () { return conversation_1.ConversationPlugin; } });
+//# sourceMappingURL=index.js.map

package/dist/plugins/sqlite-tracing.d.ts

@@ -0,0 +1,29 @@
+/**
+ * SqliteTracingPlugin — records task execution data to ~/.crewx/crewx.db.
+ *
+ * Subscribes to task:start, task:output, and task:end events and persists
+ * full records to the global CrewX SQLite database. Matches the schema
+ * written by the global crewx CLI (0.8.x).
+ *
+ * DB location: {dbRoot}/.crewx/crewx.db
+ *   (dbRoot defaults to os.homedir())
+ */
+import { CrewxPlugin } from '../plugin';
+import type { Crewx } from '../facade/Crewx';
+export interface SqliteTracingPluginOptions {
+    /** Root directory under which `.crewx/crewx.db` will be created. Defaults to `os.homedir()`. */
+    dbRoot?: string;
+    /** Caller-provided version string written into the `crewx_version` column. Defaults to `'unknown'`. */
+    version?: string;
+}
+export declare class SqliteTracingPlugin extends CrewxPlugin {
+    readonly name = "sqlite-tracing";
+    private db;
+    private unsubs;
+    private readonly dbPath;
+    private readonly version;
+    constructor(opts?: SqliteTracingPluginOptions);
+    attach(crewx: Crewx): void;
+    detach(_crewx: Crewx): void;
+}
+//# sourceMappingURL=sqlite-tracing.d.ts.map

package/dist/plugins/sqlite-tracing.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * SqliteTracingPlugin — records task execution data to ~/.crewx/crewx.db.
+ *
+ * Subscribes to task:start, task:output, and task:end events and persists
+ * full records to the global CrewX SQLite database. Matches the schema
+ * written by the global crewx CLI (0.8.x).
+ *
+ * DB location: {dbRoot}/.crewx/crewx.db
+ *   (dbRoot defaults to os.homedir())
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteTracingPlugin = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const plugin_1 = require("../plugin");
+const workspace_1 = require("../utils/workspace");
+/** Detect host AI caller agent ID from environment (set by parent crewx process). */
+function detectCallerAgentId() {
+    return process.env['CREWX_CALLER_AGENT_ID'] ?? null;
+}
+class SqliteTracingPlugin extends plugin_1.CrewxPlugin {
+    name = 'sqlite-tracing';
+    db = null;
+    unsubs = [];
+    dbPath;
+    version;
+    constructor(opts) {
+        super();
+        this.dbPath = (0, path_1.join)(opts?.dbRoot ?? (0, os_1.homedir)(), '.crewx', 'crewx.db');
+        this.version = opts?.version ?? 'unknown';
+    }
+    attach(crewx) {
+        // Ensure parent directory exists
+        const dbDir = (0, path_1.dirname)(this.dbPath);
+        if (!(0, fs_1.existsSync)(dbDir)) {
+            (0, fs_1.mkdirSync)(dbDir, { recursive: true });
+        }
+        this.db = new better_sqlite3_1.default(this.dbPath);
+        // Fallback workspace only when crewx.yaml/.yml exists in cwd — prevents phantom workspace entries
+        const cwd = process.cwd();
+        const yamlExists = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'crewx.yaml')) || (0, fs_1.existsSync)((0, path_1.join)(cwd, 'crewx.yml'));
+        const fallbackWorkspaceId = yamlExists ? (0, workspace_1.hashWorkspaceId)(cwd) : null;
+        const fallbackWorkspaceName = yamlExists ? (0, path_1.basename)(cwd) : null;
+        const callerAgentId = detectCallerAgentId();
+        const command = process.argv.join(' ');
+        this.unsubs.push(crewx.on('task:start', (event) => {
+            try {
+                const metadata = event.metadata
+                    ? JSON.stringify(event.metadata)
+                    : JSON.stringify({ provider: event.provider ?? 'cli/claude' });
+                this.db.prepare(`INSERT OR IGNORE INTO tasks
+               (id, agent_id, prompt, mode, status, pid, started_at,
+                crewx_version, platform,
+                model, rendered_prompt, command, coding_agent_command,
+                workspace_id, workspace_name,
+                caller_agent_id, trace_id, metadata, thread_id)
+             VALUES (?, ?, ?, ?, 'running', ?, ?,
+                     ?, ?,
+                     ?, ?, ?, ?,
+                     ?, ?,
+                     ?, ?, ?, ?)`).run(event.traceId, event.agentRef.replace(/^@/, ''), event.message, event.mode, event.pid ?? null, event.timestamp.toISOString(), this.version, event.platform ?? 'cli', event.model ?? null, event.renderedPrompt ?? null, command, event.codingAgentCommand ?? null, event.workspaceId ?? fallbackWorkspaceId, event.workspaceName ?? fallbackWorkspaceName, callerAgentId, event.traceId, // trace_id mirrors the task id for root requests
+                metadata, event.threadId ?? null);
+            }
+            catch {
+                // Non-fatal: tracing must never crash the main process
+            }
+        }), crewx.on('task:output', (event) => {
+            try {
+                const row = this.db.prepare('SELECT logs FROM tasks WHERE id=?').get(event.traceId);
+                const existing = row?.logs ? JSON.parse(row.logs) : [];
+                existing.push({
+                    timestamp: event.timestamp.toISOString(),
+                    level: event.level ?? 'stdout',
+                    message: event.output,
+                });
+                this.db.prepare('UPDATE tasks SET logs=? WHERE id=?').run(JSON.stringify(existing), event.traceId);
+            }
+            catch {
+                // Non-fatal
+            }
+        }), crewx.on('task:end', (event) => {
+            try {
+                const status = event.error ? 'failed' : 'success';
+                this.db.prepare(`UPDATE tasks
+             SET status=?, result=?, error=?,
+                 completed_at=?, duration_ms=?,
+                 exit_code=?,
+                 input_tokens=?, output_tokens=?, cached_input_tokens=?,
+                 cost_usd=?,
+                 model=COALESCE(?, model)
+             WHERE id=?`).run(status, event.result ?? null, event.error ? JSON.stringify(event.error) : null, event.timestamp.toISOString(), event.durationMs, event.exitCode ?? null, event.inputTokens ?? 0, event.outputTokens ?? 0, event.cachedInputTokens ?? 0, event.costUsd ?? 0, event.model ?? null, event.traceId);
+            }
+            catch {
+                // Non-fatal
+            }
+        }));
+    }
+    detach(_crewx) {
+        this.unsubs.forEach(fn => fn());
+        this.unsubs = [];
+        this.db?.close();
+        this.db = null;
+    }
+}
+exports.SqliteTracingPlugin = SqliteTracingPlugin;
+//# sourceMappingURL=sqlite-tracing.js.map

package/dist/provider/bridge.browser.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Browser-safe provider bridge.
+ * Registry pattern only — no child_process / CLI spawn.
+ */
+export declare class ProviderError extends Error {
+    readonly providerStr: string;
+    constructor(message: string, providerStr: string);
+}
+/** Factory function that creates a ProviderRuntime for a given provider id within a namespace. */
+export type ProviderFactory = (id: string, providerStr: string) => ProviderRuntime;
+/** Usage data extracted from provider output. */
+export interface ProviderUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+}
+export interface ProviderQueryOptions {
+    model?: string;
+    context?: string;
+    systemPrompt?: string;
+    additionalArgs?: string[];
+    onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
+    onPid?: (pid: number) => void;
+    onCommand?: (command: string) => void;
+    onUsage?: (usage: ProviderUsage) => void;
+    onExitCode?: (code: number) => void;
+    onModel?: (model: string) => void;
+}
+export interface ProviderRuntime {
+    query(message: string, options?: ProviderQueryOptions): Promise<string>;
+    execute(message: string, options?: ProviderQueryOptions): Promise<string>;
+}
+/**
+ * Register a provider factory for a given namespace.
+ *
+ * @example
+ * registerProviderFactory('api', (id, providerStr) => ({
+ *   async query(message, options) { ... },
+ *   async execute(message, options) { ... },
+ * }));
+ */
+export declare function registerProviderFactory(namespace: string, factory: ProviderFactory): void;
+/**
+ * Create a provider runtime for the given provider string.
+ * Browser version — only supports registered factories (no CLI fallback).
+ */
+export declare function createProvider(providerStr: string): ProviderRuntime;
+//# sourceMappingURL=bridge.browser.d.ts.map

package/dist/provider/bridge.browser.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Browser-safe provider bridge.
+ * Registry pattern only — no child_process / CLI spawn.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderError = void 0;
+exports.registerProviderFactory = registerProviderFactory;
+exports.createProvider = createProvider;
+class ProviderError extends Error {
+    providerStr;
+    constructor(message, providerStr) {
+        super(message);
+        this.providerStr = providerStr;
+        this.name = 'ProviderError';
+    }
+}
+exports.ProviderError = 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) { ... },
+ * }));
+ */
+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).
+ */
+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

package/dist/provider/bridge.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Provider bridge: creates a runtime that can invoke AI providers.
+ *
+ * Supports a registry pattern — built-in cli/* providers are registered by default,
+ * and additional namespaces (e.g. api/*, webllm/*) can be added via registerProviderFactory().
+ */
+export declare function parseStreamJsonOutput(raw: string): string;
+export declare function parseResultEventUsage(raw: string): ProviderUsage | null;
+export declare class ProviderError extends Error {
+    readonly providerStr: string;
+    constructor(message: string, providerStr: string);
+}
+/** Describes a pending client-side tool call that requires external execution. */
+export interface ClientToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+/** Opaque state needed to resume a conversation after a client tool call. */
+export interface ContinuationState {
+    userMessage: string;
+    responseMessages: unknown[];
+    toolDefinitions: import('../facade/Crewx').ToolDefinition[];
+    maxSteps: number;
+    systemPrompt?: string;
+    modelOverride?: string;
+}
+/**
+ * Thrown by VercelProviderRuntime when generateText() encounters a tool without
+ * an execute function (client tool). The caller should return requires_action
+ * to the client, collect the tool result, and call continueWithToolResults().
+ */
+export declare class ClientToolCallRequiredError extends Error {
+    readonly toolCall: ClientToolCall;
+    readonly continuationState: ContinuationState;
+    readonly name = "ClientToolCallRequiredError";
+    constructor(toolCall: ClientToolCall, continuationState: ContinuationState);
+}
+/** Factory function that creates a ProviderRuntime for a given provider id within a namespace. */
+export type ProviderFactory = (id: string, providerStr: string) => ProviderRuntime;
+/**
+ * Register a provider factory for a given namespace.
+ *
+ * @example
+ * // Register an API-based provider namespace
+ * registerProviderFactory('api', (id, providerStr) => new MyApiProvider(id));
+ *
+ * // Now createProvider('api/claude') works
+ * const provider = createProvider('api/claude');
+ */
+export declare function registerProviderFactory(namespace: string, factory: ProviderFactory): void;
+/** Usage data extracted from provider stream-json output. */
+export interface ProviderUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+}
+export interface ProviderQueryOptions {
+    model?: string;
+    context?: string;
+    systemPrompt?: string;
+    /** Provider-specific CLI args from agent config (e.g. ['exec', '--json'] for codex). Replaces hardcoded defaults when provided. */
+    additionalArgs?: string[];
+    /** Called with each completed output line from the provider process. */
+    onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
+    /** Called once with the child process PID, right after spawn. */
+    onPid?: (pid: number) => void;
+    /** Called with the full CLI command string (e.g. "claude -p ... --output-format stream-json"). */
+    onCommand?: (command: string) => void;
+    /** Called with token usage once the result event is parsed. */
+    onUsage?: (usage: ProviderUsage) => void;
+    /** Called with the process exit code on close. */
+    onExitCode?: (code: number) => void;
+    /** Called with the actual model used (from result event's modelUsage key). */
+    onModel?: (model: string) => void;
+    /** CREWX_* env vars injected by facade for hook context propagation */
+    env?: Record<string, string>;
+    /** Working directory for CLI provider process (overrides process.cwd). Used by file:// remote delegation. */
+    cwd?: string;
+    /** Vercel AI SDK에 주입할 tools. registerTool()로 등록한 것 중 필터링된 목록. */
+    tools?: import('../facade/Crewx').ToolDefinition[];
+    /** Agent generate() 최대 반복 횟수. 기본값 10, 최대 50. */
+    maxSteps?: number;
+}
+export interface ProviderRuntime {
+    query(message: string, options?: ProviderQueryOptions): Promise<string>;
+    execute(message: string, options?: ProviderQueryOptions): Promise<string>;
+    /** Resume a conversation after providing client-side tool results. Only implemented by API providers. */
+    continueWithToolResults?(continuationState: ContinuationState, toolResults: Array<{
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    }>, options?: ProviderQueryOptions): Promise<string>;
+}
+/**
+ * Create a provider runtime for the given provider string.
+ *
+ * Looks up the namespace in the provider registry first.
+ * Falls back to built-in cli/* providers for backward compatibility.
+ *
+ * @param providerStr - Provider string in namespace/id format (e.g., 'cli/claude', 'api/claude')
+ * @throws ProviderError for unknown or unsupported providers
+ */
+export declare function createProvider(providerStr: string): ProviderRuntime;
+//# sourceMappingURL=bridge.d.ts.map