@crewx/workflow 0.3.21 → 0.3.22-rc.10

package/dist/src/run-manager.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunManager = void 0;
+exports.RunManager = exports.SKILL_TASK_DEFAULT_TIMEOUT = void 0;
 exports.parseSetArgs = parseSetArgs;
 exports.readStdin = readStdin;
 exports.interpolateTemplate = interpolateTemplate;
@@ -45,6 +45,112 @@ const cp = __importStar(require("child_process"));
 const sdk_1 = require("@crewx/sdk");
 const file_lock_1 = require("./file-lock");
 const output_format_1 = require("./utils/output-format");
+const shell_security_1 = require("./utils/shell-security");
+exports.SKILL_TASK_DEFAULT_TIMEOUT = 600000;
+const KNOWN_AUTO_NODE_TYPES = new Set([
+    'agent_task', 'skill_task', 'shell_task', 'branch', 'expression', 'join', 'end',
+]);
+const SELF_ADVANCING_NODE_TYPES = new Set(['branch', 'expression', 'end']);
+function killProcessGroup(child) {
+    try {
+        if (process.platform === 'win32') {
+            if (child.pid) {
+                cp.spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+            }
+        }
+        else if (child.pid) {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+}
+async function runProcess(command, argv, opts) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = cp.spawn(command, argv, {
+                cwd: opts.cwd,
+                env: opts.env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: opts.shell ?? false,
+                detached: process.platform !== 'win32',
+                windowsHide: opts.windowsHide ?? true,
+            });
+        }
+        catch (err) {
+            resolve({ status: null, stdout: '', stderr: '', timedOut: false, error: err });
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            killProcessGroup(child);
+            finish({ status: null, stdout, stderr, timedOut: true });
+        }, opts.timeout);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('error', (err) => finish({ status: null, stdout, stderr, timedOut: false, error: err }));
+        child.on('close', (code) => finish({ status: code, stdout, stderr, timedOut: false }));
+    });
+}
+function maskArg(arg) {
+    return arg.replace(/^(--?[\w-]*(?:token|secret|password|passwd|key|auth)[\w-]*)=(.+)$/i, '$1=***');
+}
+function summarizeNode(node) {
+    switch (node.type) {
+        case 'agent_task':
+            return `@${node.agent ?? '?'} (${node.mode === 'query' ? 'q' : 'x'})`;
+        case 'skill_task':
+            return `skill ${node.skill ?? '?'} ${(node.args ?? []).map(maskArg).join(' ')}`.trim();
+        case 'shell_task':
+            return (node.command ?? []).map(maskArg).join(' ');
+        case 'branch':
+            return `branch: ${node.condition ?? ''}`;
+        case 'expression':
+            return `set ${Object.keys(node.set ?? {}).join(', ')}`;
+        default:
+            return node.type;
+    }
+}
+async function storeNodeOutput(nodeSpec, nodeId, stdout, stateUpdates) {
+    if (!nodeSpec.output)
+        return;
+    const trimmed = stdout.trim();
+    if (nodeSpec.output_format === 'json') {
+        let parsed;
+        try {
+            parsed = JSON.parse((0, output_format_1.extractJson)(trimmed));
+        }
+        catch (e) {
+            throw new Error(`Node "${nodeId}" output_format=json parse failed: ${e.message}`);
+        }
+        if (nodeSpec.output_schema) {
+            await (0, output_format_1.validateJsonSchema)(parsed, nodeSpec.output_schema);
+        }
+        stateUpdates[nodeSpec.output] = parsed;
+    }
+    else {
+        stateUpdates[nodeSpec.output] = trimmed;
+    }
+}
 function parseValue(raw) {
     try {
         return JSON.parse(raw);
@@ -360,10 +466,11 @@ function safeEvaluate(expr, state) {
     return parser.parse();
 }
 class RunManager {
-    constructor(runsDir = '.crewx/workflow-runs') {
+    constructor(runsDir = '.crewx/workflow-runs', projectRoot) {
         this.runsDir = runsDir;
-        const base = process.env.CREWX_WORKSPACE || process.cwd();
+        const base = projectRoot || process.env.CREWX_WORKSPACE || process.cwd();
         this.resolvedDir = path.resolve(base, this.runsDir);
+        this.projectRoot = path.resolve(base);
     }
     ensureRunsDir() {
         if (!fs.existsSync(this.resolvedDir)) {
@@ -522,6 +629,26 @@ class RunManager {
         let currentNode = nodeId;
         let status;
         let nodeTaskId;
+        const trigger = opts?.trigger ?? 'manual';
+        const startedAt = new Date();
+        let nodeStdout = '';
+        let nodeStderr = '';
+        let nodeExitCode = null;
+        const buildAudit = (error) => {
+            const endedAt = new Date();
+            return {
+                exec_id: snapshot.id,
+                node_id: nodeId,
+                type: nodeSpec.type,
+                summary: summarizeNode(nodeSpec),
+                started_at: startedAt.toISOString(),
+                ended_at: endedAt.toISOString(),
+                duration_ms: endedAt.getTime() - startedAt.getTime(),
+                exit_code: nodeExitCode,
+                ...(error ? { error } : {}),
+                trigger,
+            };
+        };
         try {
             switch (nodeSpec.type) {
                 case 'agent_task': {
@@ -545,7 +672,7 @@ class RunManager {
                     const cliParts = crewxCli.split(/\s+/);
                     const bin = cliParts[0];
                     const baseArgs = cliParts.slice(1);
-                    const nodeTimeout = Number(process.env[mode === 'q' ? 'CREWX_TIMEOUT_QUERY' : 'CREWX_TIMEOUT_EXECUTE']) || 3600000;
+                    const nodeTimeout = Number(process.env[mode === 'q' ? 'CREWX_TIMEOUT_QUERY' : 'CREWX_TIMEOUT_EXECUTE']) || 8 * 3600000;
                     const wfArgs = [...baseArgs, mode, prompt];
                     if (process.env.CREWX_WORKFLOW_THREAD === 'on') {
                         wfArgs.push(`--thread=workflow:${snapshot.id}`);
@@ -564,30 +691,34 @@ class RunManager {
                         packageName: 'crewx',
                     });
                     const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, wfArgs);
-                    const result = cp.spawnSync(invocation.command, invocation.argv, {
-                        encoding: 'utf-8',
-                        timeout: nodeTimeout,
+                    const result = await runProcess(invocation.command, invocation.argv, {
                         cwd: process.cwd(),
-                        stdio: ['inherit', 'pipe', 'pipe'],
-                        shell: invocation.shell ?? false,
-                        windowsHide: invocation.windowsHide,
                         env: {
                             ...process.env,
                             CREWX_WORKFLOW_EXEC_ID: snapshot.id,
                             CREWX_WORKFLOW_NODE_ID: nodeId,
                             CREWX_WORKFLOW_ID: snapshot.workflow_id,
                         },
+                        timeout: nodeTimeout,
+                        shell: invocation.shell ?? false,
+                        windowsHide: invocation.windowsHide,
                     });
+                    nodeStdout = result.stdout;
+                    nodeStderr = result.stderr;
+                    nodeExitCode = result.status;
                     if (result.error) {
                         throw result.error;
                     }
-                    const taskIdMatch = result.stderr?.match(/crewx kill (tsk_\w+)/);
+                    if (result.timedOut) {
+                        throw new Error(`Agent execution timed out after ${nodeTimeout}ms`);
+                    }
+                    const taskIdMatch = result.stderr.match(/crewx kill (tsk_\w+)/);
                     nodeTaskId = taskIdMatch?.[1];
                     if (result.status !== 0) {
-                        const stderr = result.stderr?.trim() ?? '';
+                        const stderr = result.stderr.trim();
                         throw new Error(`Agent execution failed (exit ${result.status}): ${stderr}`);
                     }
-                    const output = result.stdout?.trim() ?? '';
+                    const output = result.stdout.trim();
                     if (nodeSpec.output) {
                         if (nodeSpec.output_format === 'json') {
                             const retryMax = nodeSpec.output_retry ?? 1;
@@ -607,26 +738,29 @@ class RunManager {
                                     }
                                     retryArgs.push('--metadata', JSON.stringify(wfMetadata));
                                     const retryInvocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, retryArgs);
-                                    const retryResult = cp.spawnSync(retryInvocation.command, retryInvocation.argv, {
-                                        encoding: 'utf-8',
-                                        timeout: nodeTimeout,
+                                    const retryResult = await runProcess(retryInvocation.command, retryInvocation.argv, {
                                         cwd: process.cwd(),
-                                        stdio: ['inherit', 'pipe', 'pipe'],
-                                        shell: retryInvocation.shell ?? false,
-                                        windowsHide: retryInvocation.windowsHide,
                                         env: {
                                             ...process.env,
                                             CREWX_WORKFLOW_EXEC_ID: snapshot.id,
                                             CREWX_WORKFLOW_NODE_ID: nodeId,
                                             CREWX_WORKFLOW_ID: snapshot.workflow_id,
                                         },
+                                        timeout: nodeTimeout,
+                                        shell: retryInvocation.shell ?? false,
+                                        windowsHide: retryInvocation.windowsHide,
                                     });
+                                    nodeStdout = retryResult.stdout;
+                                    nodeStderr = retryResult.stderr;
+                                    nodeExitCode = retryResult.status;
                                     if (retryResult.error)
                                         throw retryResult.error;
+                                    if (retryResult.timedOut)
+                                        throw new Error(`Agent retry timed out after ${nodeTimeout}ms`);
                                     if (retryResult.status !== 0) {
-                                        throw new Error(`Agent retry failed (exit ${retryResult.status}): ${retryResult.stderr?.trim()}`);
+                                        throw new Error(`Agent retry failed (exit ${retryResult.status}): ${retryResult.stderr.trim()}`);
                                     }
-                                    attemptOutput = retryResult.stdout?.trim() ?? '';
+                                    attemptOutput = retryResult.stdout.trim();
                                 }
                                 try {
                                     parsed = JSON.parse((0, output_format_1.extractJson)(attemptOutput));
@@ -652,6 +786,118 @@ class RunManager {
                     }
                     break;
                 }
+                case 'skill_task': {
+                    if (!nodeSpec.skill) {
+                        throw new Error(`Node "${nodeId}" is skill_task but has no skill defined`);
+                    }
+                    if (!shell_security_1.SKILL_NAME_RE.test(nodeSpec.skill)) {
+                        throw new Error(`Node "${nodeId}" has invalid skill name "${nodeSpec.skill}" (must match ^[a-z0-9][a-z0-9-]*$)`);
+                    }
+                    const ctx = { ...snapshot.state, state: snapshot.state };
+                    const skillArgs = (nodeSpec.args ?? []).map((a) => interpolateTemplate(String(a), ctx));
+                    const cwdCheck = (0, shell_security_1.normalizeCwd)(nodeSpec.cwd ? interpolateTemplate(nodeSpec.cwd, ctx) : undefined, this.projectRoot);
+                    if (!cwdCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${cwdCheck.error}`);
+                    const timeout = nodeSpec.timeout ?? exports.SKILL_TASK_DEFAULT_TIMEOUT;
+                    if (opts?.dryRun) {
+                        console.log(`[dry-run] Would execute: crewx skill ${nodeSpec.skill} ${skillArgs.join(' ')}`.trim());
+                        break;
+                    }
+                    console.log(`Executing skill: ${nodeSpec.skill} ${skillArgs.join(' ')}`.trim());
+                    const crewxCli = process.env.CREWX_CLI || 'npx crewx';
+                    const cliParts = crewxCli.split(/\s+/);
+                    const bin = cliParts[0];
+                    const baseArgs = cliParts.slice(1);
+                    const skillArgv = [...baseArgs, 'skill', nodeSpec.skill, ...skillArgs];
+                    const program = (0, sdk_1.resolveWindowsSpawnProgram)({
+                        command: bin,
+                        allowShellFallback: true,
+                        packageName: 'crewx',
+                    });
+                    const invocation = (0, sdk_1.materializeWindowsSpawnProgram)(program, skillArgv);
+                    const result = await runProcess(invocation.command, invocation.argv, {
+                        cwd: cwdCheck.resolved,
+                        env: {
+                            ...process.env,
+                            CREWX_WORKFLOW_EXEC_ID: snapshot.id,
+                            CREWX_WORKFLOW_NODE_ID: nodeId,
+                            CREWX_WORKFLOW_ID: snapshot.workflow_id,
+                        },
+                        timeout,
+                        shell: invocation.shell ?? false,
+                        windowsHide: invocation.windowsHide,
+                    });
+                    nodeStdout = result.stdout;
+                    nodeStderr = result.stderr;
+                    nodeExitCode = result.status;
+                    if (result.error)
+                        throw result.error;
+                    if (result.timedOut)
+                        throw new Error(`skill_task "${nodeId}" timed out after ${timeout}ms`);
+                    if (result.status !== 0) {
+                        throw new Error(`skill_task "${nodeId}" failed (exit ${result.status}): ${result.stderr.trim()}`);
+                    }
+                    await storeNodeOutput(nodeSpec, nodeId, result.stdout, stateUpdates);
+                    if (nodeSpec.output) {
+                        console.log(`Result stored in state.${nodeSpec.output}`);
+                    }
+                    break;
+                }
+                case 'shell_task': {
+                    const shellEnvEnabled = process.env.CREWX_WORKFLOW_SHELL === '1';
+                    const shellMetaAllowed = spec.metadata?.shell_task_allowed === true;
+                    if (!shellEnvEnabled || !shellMetaAllowed) {
+                        throw new Error('shell_task is disabled. Set CREWX_WORKFLOW_SHELL=1 and metadata.shell_task_allowed=true to enable.');
+                    }
+                    const cmdCheck = (0, shell_security_1.validateShellCommand)(nodeSpec.command);
+                    if (!cmdCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${cmdCheck.error}`);
+                    const envCheck = (0, shell_security_1.validateEnvKeys)(nodeSpec.env);
+                    if (!envCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${envCheck.error}`);
+                    const ctx = { ...snapshot.state, state: snapshot.state };
+                    const command = nodeSpec.command.map((c) => interpolateTemplate(c, ctx));
+                    const postCheck = (0, shell_security_1.validateShellCommand)(command);
+                    if (!postCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${postCheck.error}`);
+                    const interpolatedEnv = nodeSpec.env
+                        ? Object.fromEntries(Object.entries(nodeSpec.env).map(([k, v]) => [k, interpolateTemplate(String(v), ctx)]))
+                        : undefined;
+                    const cwdCheck = (0, shell_security_1.normalizeCwd)(nodeSpec.cwd ? interpolateTemplate(nodeSpec.cwd, ctx) : undefined, this.projectRoot);
+                    if (!cwdCheck.ok)
+                        throw new Error(`Node "${nodeId}": ${cwdCheck.error}`);
+                    const timeout = nodeSpec.timeout ?? exports.SKILL_TASK_DEFAULT_TIMEOUT;
+                    if (opts?.dryRun) {
+                        console.log(`[dry-run] Would execute: ${command.join(' ')}`);
+                        break;
+                    }
+                    console.log(`Executing shell_task: ${command[0]} (${command.length - 1} args)`);
+                    const childEnv = (0, shell_security_1.buildShellEnv)(interpolatedEnv, process.env);
+                    childEnv.CREWX_WORKFLOW_EXEC_ID = snapshot.id;
+                    childEnv.CREWX_WORKFLOW_NODE_ID = nodeId;
+                    childEnv.CREWX_WORKFLOW_ID = snapshot.workflow_id;
+                    const result = await runProcess(command[0], command.slice(1), {
+                        cwd: cwdCheck.resolved,
+                        env: childEnv,
+                        timeout,
+                        shell: false,
+                    });
+                    nodeStdout = result.stdout;
+                    nodeStderr = result.stderr;
+                    nodeExitCode = result.status;
+                    if (result.error)
+                        throw result.error;
+                    if (result.timedOut)
+                        throw new Error(`shell_task "${nodeId}" timed out after ${timeout}ms`);
+                    if (result.status !== 0) {
+                        throw new Error(`shell_task "${nodeId}" failed (exit ${result.status}): ${result.stderr.trim()}`);
+                    }
+                    await storeNodeOutput(nodeSpec, nodeId, result.stdout, stateUpdates);
+                    if (nodeSpec.output) {
+                        console.log(`Result stored in state.${nodeSpec.output}`);
+                    }
+                    break;
+                }
                 case 'branch': {
                     if (!nodeSpec.condition) {
                         throw new Error(`Branch node "${nodeId}" has no condition`);
@@ -710,13 +956,27 @@ class RunManager {
             }
         }
         catch (e) {
+            const errMessage = e.message;
+            const partial = [
+                nodeStdout.trim() ? `stdout: ${nodeStdout.trim().slice(-500)}` : '',
+                nodeStderr.trim() ? `stderr: ${nodeStderr.trim().slice(-500)}` : '',
+            ].filter(Boolean).join(' | ');
+            const auditEntry = buildAudit(partial ? `${errMessage} (${partial})` : errMessage);
             await this.atomicUpdateAsync(execId, (run) => {
+                if (run.status === 'cancelled')
+                    return;
                 run.current_node = nodeId;
                 run.status = 'failed';
+                run.error = errMessage;
+                run.audit = run.audit ?? [];
+                run.audit.push(auditEntry);
             });
             throw e;
         }
+        const successAudit = buildAudit();
         return this.atomicUpdateAsync(execId, (run) => {
+            if (run.status === 'cancelled')
+                return;
             Object.assign(run.state, stateUpdates);
             for (const node of nodesToComplete) {
                 if (!run.completed_nodes.includes(node)) {
@@ -733,6 +993,119 @@ class RunManager {
                 run.tasks = run.tasks ?? {};
                 run.tasks[nodeId] = nodeTaskId;
             }
+            run.audit = run.audit ?? [];
+            run.audit.push(successAudit);
+        });
+    }
+    async runAuto(execId) {
+        const initial = this.loadRun(execId);
+        if (!initial)
+            throw new Error(`Execution not found: ${execId}`);
+        const doc = this.loadWorkflowYaml(initial.workflow_file);
+        if (!doc)
+            throw new Error(`Failed to load workflow file: ${initial.workflow_file}`);
+        const spec = doc.workflows[initial.workflow_id];
+        if (!spec) {
+            throw new Error(`Workflow "${initial.workflow_id}" not found in ${initial.workflow_file}`);
+        }
+        const executed = [];
+        if (initial.status === 'completed' || initial.status === 'failed' || initial.status === 'cancelled') {
+            return {
+                run: initial,
+                outcome: initial.status === 'completed' ? 'completed' : initial.status === 'cancelled' ? 'cancelled' : 'failed',
+                reason: `run already ${initial.status}`,
+                executed,
+            };
+        }
+        const firstNode = Object.keys(spec.nodes ?? {})[0];
+        const maxIterations = (typeof spec.max_iterations === 'number' && spec.max_iterations > 0)
+            ? spec.max_iterations
+            : 30;
+        const visitCounts = {};
+        let iterations = 0;
+        let run = initial;
+        while (true) {
+            run = this.loadRun(execId);
+            if (run.status === 'completed')
+                return { run, outcome: 'completed', executed };
+            if (run.status === 'failed')
+                return { run, outcome: 'failed', reason: run.error, executed };
+            if (run.status === 'cancelled')
+                return { run, outcome: 'cancelled', reason: run.error, executed };
+            const nodeId = run.current_node || firstNode;
+            if (!nodeId)
+                return { run, outcome: 'failed', reason: 'workflow has no nodes', executed };
+            const node = spec.nodes[nodeId];
+            if (!node) {
+                run = await this.atomicUpdateAsync(execId, (r) => {
+                    r.current_node = nodeId;
+                    r.status = 'failed';
+                    r.error = `node "${nodeId}" not found in workflow`;
+                });
+                return { run, outcome: 'failed', reason: run.error, executed };
+            }
+            if (node.type === 'approval') {
+                return { run, outcome: 'paused', reason: `approval node "${nodeId}" requires manual decision`, executed };
+            }
+            if (node.type === 'parallel') {
+                return { run, outcome: 'paused', reason: `parallel auto-run not implemented (node "${nodeId}")`, executed };
+            }
+            if (!KNOWN_AUTO_NODE_TYPES.has(node.type)) {
+                return { run, outcome: 'paused', reason: `unknown node type "${node.type}" (node "${nodeId}")`, executed };
+            }
+            visitCounts[nodeId] = (visitCounts[nodeId] ?? 0) + 1;
+            iterations++;
+            if (visitCounts[nodeId] > maxIterations || iterations > maxIterations) {
+                run = await this.atomicUpdateAsync(execId, (r) => {
+                    r.status = 'failed';
+                    r.error = `auto runner exceeded max_iterations (${maxIterations}); possible loop at "${nodeId}"`;
+                });
+                return { run, outcome: 'failed', reason: run.error, executed };
+            }
+            try {
+                run = await this.executeNode(execId, nodeId, { trigger: 'auto' });
+                executed.push(nodeId);
+            }
+            catch (e) {
+                run = this.loadRun(execId);
+                return { run, outcome: 'failed', reason: e.message, executed };
+            }
+            if (run.status === 'completed')
+                return { run, outcome: 'completed', executed };
+            if (run.status === 'failed')
+                return { run, outcome: 'failed', reason: run.error, executed };
+            if (run.status === 'cancelled')
+                return { run, outcome: 'cancelled', reason: run.error, executed };
+            if (!SELF_ADVANCING_NODE_TYPES.has(node.type)) {
+                const next = node.next;
+                if (!next) {
+                    return { run, outcome: 'paused', reason: `node "${nodeId}" has no "next"; stopping`, executed };
+                }
+                run = this.moveNode(execId, next);
+            }
+        }
+    }
+    cancelRun(execId, reason = 'Cancelled by user') {
+        return this.atomicUpdate(execId, (run) => {
+            if (run.status === 'completed' || run.status === 'failed' || run.status === 'cancelled') {
+                return;
+            }
+            const now = new Date();
+            run.status = 'cancelled';
+            run.error = reason;
+            run.audit = run.audit ?? [];
+            run.audit.push({
+                exec_id: run.id,
+                node_id: run.current_node || '',
+                type: 'cancel',
+                summary: reason,
+                started_at: now.toISOString(),
+                ended_at: now.toISOString(),
+                duration_ms: 0,
+                exit_code: null,
+                error: reason,
+                trigger: 'manual',
+            });
         });
     }
     reset(execId) {