@crewx/cli 0.8.0-rc.66 → 0.8.0-rc.82

package/dist/commands/parse-common-flags.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Common flag parser for query/execute commands.
+ *
+ * Supports both `--flag=value` and `--flag value` forms.
+ * Handles: --thread, --provider, --metadata, --verbose, --config/-c,
+ *          --output-format, --effort.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommonFlags = parseCommonFlags;
+exports.parseMetadata = parseMetadata;
+/**
+ * Parse a single-value flag from an args array.
+ * Supports `--flag=value` and `--flag value` forms.
+ * Returns undefined if flag is not present.
+ */
+function parseFlag(args, ...names) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        for (const name of names) {
+            const prefix = `${name}=`;
+            if (arg.startsWith(prefix)) {
+                return arg.slice(prefix.length);
+            }
+            if (arg === name && i + 1 < args.length) {
+                return args[i + 1];
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a boolean flag is present.
+ */
+function hasFlag(args, ...names) {
+    return names.some(name => args.includes(name));
+}
+/**
+ * Parse common CLI flags from an args array.
+ * Returns parsed flags and remaining positional arguments.
+ */
+function parseCommonFlags(args) {
+    const thread = parseFlag(args, '--thread');
+    const provider = parseFlag(args, '--provider');
+    const metadata = parseFlag(args, '--metadata');
+    const config = parseFlag(args, '--config', '-c');
+    const outputFormat = parseFlag(args, '--output-format');
+    const effort = parseFlag(args, '--effort');
+    const verbose = hasFlag(args, '--verbose');
+    // Collect the set of consumed positions
+    const consumed = new Set();
+    const flagPairs = [
+        { names: ['--thread'] },
+        { names: ['--provider'] },
+        { names: ['--metadata'] },
+        { names: ['--config', '-c'] },
+        { names: ['--output-format'] },
+        { names: ['--effort'] },
+    ];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        // Boolean flags
+        if (arg === '--verbose') {
+            consumed.add(i);
+            continue;
+        }
+        // Value flags
+        for (const { names } of flagPairs) {
+            for (const name of names) {
+                if (arg.startsWith(`${name}=`)) {
+                    consumed.add(i);
+                }
+                else if (arg === name) {
+                    consumed.add(i);
+                    if (i + 1 < args.length)
+                        consumed.add(i + 1);
+                }
+            }
+        }
+    }
+    const rest = args.filter((_, i) => !consumed.has(i));
+    return { thread, provider, metadata, verbose, config, outputFormat, effort, rest };
+}
+/**
+ * Parse metadata JSON string from --metadata flag.
+ * Returns empty object when no raw value provided.
+ * Throws Error on invalid JSON or non-object values (fail-fast).
+ */
+function parseMetadata(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        throw new Error(`--metadata must be a JSON object. Got: ${raw}`);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith('--metadata must be a JSON object')) {
+            throw err;
+        }
+        throw new Error(`--metadata must be valid JSON (double-quoted). Got: ${raw}`);
+    }
+}

package/dist/commands/ps.d.ts

@@ -0,0 +1,12 @@
+/**
+ * crewx ps handler.
+ * Lists currently running tasks in table format.
+ *
+ * Usage:
+ *   crewx ps           List all running tasks
+ *   crewx ps --json    Output as JSON array
+ */
+/**
+ * Handle `crewx ps` command.
+ */
+export declare function handlePs(args: string[]): Promise<void>;

package/dist/commands/ps.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * crewx ps handler.
+ * Lists currently running tasks in table format.
+ *
+ * Usage:
+ *   crewx ps           List all running tasks
+ *   crewx ps --json    Output as JSON array
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePs = handlePs;
+const task_db_1 = require("./task-db");
+/**
+ * Format elapsed milliseconds into a human-readable string.
+ */
+function formatElapsed(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return `${m}m ${rs}s`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m`;
+}
+/**
+ * Format a task row into a table row.
+ */
+function taskToRow(task) {
+    const elapsed = formatElapsed(Date.now() - new Date(task.started_at).getTime());
+    return [
+        task.id,
+        task.agent_id,
+        task.pid !== null ? String(task.pid) : '—',
+        elapsed,
+        task.mode,
+    ];
+}
+/**
+ * Render a table with padded columns.
+ */
+function renderTable(headers, rows) {
+    const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map(r => (r[i] ?? '').length)));
+    const separator = colWidths.map(w => '-'.repeat(w)).join('  ');
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i] ?? h.length)).join('  ');
+    console.log(headerLine);
+    console.log(separator);
+    for (const row of rows) {
+        console.log(row.map((cell, i) => cell.padEnd(colWidths[i] ?? cell.length)).join('  '));
+    }
+}
+/**
+ * Handle `crewx ps` command.
+ */
+async function handlePs(args) {
+    const tasks = (0, task_db_1.getRunningTasks)();
+    if (tasks.length === 0) {
+        console.log('No running tasks.');
+        return;
+    }
+    // --json output
+    if (args.includes('--json')) {
+        console.log(JSON.stringify(tasks, null, 2));
+        return;
+    }
+    const headers = ['TASK ID', 'AGENT', 'PID', 'ELAPSED', 'MODE'];
+    const rows = tasks.map(taskToRow);
+    renderTable(headers, rows);
+    console.log(`\n  ${tasks.length} running task(s)`);
+}

package/dist/commands/query.d.ts

@@ -0,0 +1,21 @@
+/**
+ * crewx query handler.
+ * Parses args, loads config via Crewx SDK, and executes the query.
+ *
+ * Flags:
+ *   --thread <name>          Conversation thread name
+ *   --provider <cli/xxx>     Provider override
+ *   --metadata <json>        Extra metadata JSON (double-quoted object). Propagated to events/hooks/tracing.
+ *                           e.g. --metadata='{"workflow_id":"wf-1"}'
+ *   --verbose                Debug output mode (default: raw agent response only)
+ *   --config/-c <path>       Config file path override
+ *   --output-format <fmt>    Output format (json|text|stream-json)
+ *   --effort <level>         Model effort (high|medium|low)
+ */
+/**
+ * Handle `crewx query <agentRef> <message>` command.
+ *
+ * Default output: raw agent response only (stdout).
+ * --verbose: debug info written to stderr, response to stdout.
+ */
+export declare function handleQuery(args: string[]): Promise<void>;

package/dist/commands/query.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * crewx query handler.
+ * Parses args, loads config via Crewx SDK, and executes the query.
+ *
+ * Flags:
+ *   --thread <name>          Conversation thread name
+ *   --provider <cli/xxx>     Provider override
+ *   --metadata <json>        Extra metadata JSON (double-quoted object). Propagated to events/hooks/tracing.
+ *                           e.g. --metadata='{"workflow_id":"wf-1"}'
+ *   --verbose                Debug output mode (default: raw agent response only)
+ *   --config/-c <path>       Config file path override
+ *   --output-format <fmt>    Output format (json|text|stream-json)
+ *   --effort <level>         Model effort (high|medium|low)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleQuery = handleQuery;
+const sdk_1 = require("@crewx/sdk");
+const parse_agent_message_1 = require("./parse-agent-message");
+const parse_common_flags_1 = require("./parse-common-flags");
+const crewx_cli_1 = require("../bootstrap/crewx-cli");
+/**
+ * Handle `crewx query <agentRef> <message>` command.
+ *
+ * Default output: raw agent response only (stdout).
+ * --verbose: debug info written to stderr, response to stdout.
+ */
+async function handleQuery(args) {
+    const { thread, provider, metadata, verbose, config, outputFormat, effort, rest } = (0, parse_common_flags_1.parseCommonFlags)(args);
+    const { agentRef: parsedAgentRef, message } = (0, parse_agent_message_1.parseAgentMessage)(rest);
+    // No @mention → default to @crewx agent (matches cli-bak behaviour)
+    const agentRef = parsedAgentRef || '@crewx';
+    if (!message) {
+        console.error('Usage: crewx query [@agent] <message> [options]');
+        console.error('       crewx q [@agent] <message> [options]');
+        console.error('');
+        console.error('  @agent is optional. Defaults to @crewx when omitted.');
+        console.error('');
+        console.error('Options:');
+        console.error('  --thread <name>        Conversation thread name');
+        console.error('  --provider <cli/xxx>   Provider override');
+        console.error('  --metadata <json>      Extra metadata (JSON object, double-quoted).');
+        console.error('                         Propagated to events/hooks/tracing.');
+        console.error('                         Invalid JSON aborts with exit code 2.');
+        console.error('                         e.g. --metadata=\'{"workflow_id":"wf-1"}\'');
+        console.error('  --verbose              Debug output mode');
+        console.error('  --config/-c <path>     Config file path');
+        console.error('  --output-format <fmt>  Output format (json|text|stream-json)');
+        console.error('  --effort <level>       Model effort (high|medium|low)');
+        process.exit(1);
+    }
+    const configPath = config ?? process.env.CREWX_CONFIG ?? 'crewx.yaml';
+    // Only show exec audit span JSON in verbose mode
+    (0, sdk_1.setAuditVerbose)(verbose);
+    const crewx = await (0, crewx_cli_1.createCliCrewx)(configPath);
+    // file:// remote agent delegation is handled transparently inside Crewx.query/execute.
+    if (verbose) {
+        process.stderr.write(`📋 Task: ${message}\n`);
+        process.stderr.write(`🤖 Agent: ${agentRef}\n`);
+        if (thread)
+            process.stderr.write(`🔗 Thread: ${thread}\n`);
+        if (provider)
+            process.stderr.write(`🔌 Provider: ${provider}\n`);
+        if (outputFormat)
+            process.stderr.write(`📄 Output-format: ${outputFormat}\n`);
+        if (effort)
+            process.stderr.write(`⚡ Effort: ${effort}\n`);
+        process.stderr.write('─'.repeat(60) + '\n');
+    }
+    let parsedMetadata = {};
+    try {
+        parsedMetadata = (0, parse_common_flags_1.parseMetadata)(metadata);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: ${msg}\n`);
+        process.exit(2);
+    }
+    let exitCode = 0;
+    try {
+        const result = await crewx.query(agentRef, message, {
+            provider,
+            threadId: thread,
+            metadata: Object.keys(parsedMetadata).length > 0 ? parsedMetadata : undefined,
+        });
+        if (!result.ok) {
+            const errMsg = result.error?.message ?? 'Query failed';
+            console.error(errMsg);
+            exitCode = 1;
+        }
+        else {
+            if (verbose) {
+                process.stderr.write(`\n📊 Results from ${agentRef}:\n`);
+                process.stderr.write('═'.repeat(60) + '\n');
+                process.stderr.write('🟢 Status: Success\n');
+                process.stderr.write(`🤖 Provider: ${result.meta.provider}\n`);
+                process.stderr.write(`⏱️  Duration: ${result.meta.durationMs}ms\n`);
+                process.stderr.write('\n📄 Response:\n');
+                process.stderr.write('─'.repeat(40) + '\n');
+            }
+            console.log(result.data);
+            if (verbose) {
+                process.stderr.write('\n✅ Query completed successfully\n');
+            }
+        }
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${errMsg}`);
+        exitCode = 1;
+    }
+    finally {
+        await crewx.close();
+    }
+    if (exitCode !== 0)
+        process.exit(exitCode);
+}

package/dist/commands/result.d.ts

@@ -0,0 +1,13 @@
+/**
+ * crewx result handler.
+ * Retrieves the result of a completed task by its ID.
+ *
+ * Usage:
+ *   crewx result <task-id>         Print raw result
+ *   crewx result <task-id> --json  Print full task record as JSON
+ *   crewx result                   List recent tasks (latest 10)
+ */
+/**
+ * Handle `crewx result` command.
+ */
+export declare function handleResult(args: string[]): Promise<void>;

package/dist/commands/result.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * crewx result handler.
+ * Retrieves the result of a completed task by its ID.
+ *
+ * Usage:
+ *   crewx result <task-id>         Print raw result
+ *   crewx result <task-id> --json  Print full task record as JSON
+ *   crewx result                   List recent tasks (latest 10)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleResult = handleResult;
+const task_db_1 = require("./task-db");
+function statusIcon(status) {
+    switch (status) {
+        case 'running': return '⏳';
+        case 'success': return '✅';
+        case 'failed': return '❌';
+    }
+}
+/**
+ * Handle `crewx result` command.
+ */
+async function handleResult(args) {
+    const jsonMode = args.includes('--json');
+    const taskId = args.find(a => !a.startsWith('--'));
+    if (!taskId) {
+        // Show recent tasks
+        const all = (0, task_db_1.getAllTasks)();
+        const recent = all.slice(0, 10);
+        if (recent.length === 0) {
+            console.log('No tasks found.');
+            console.log('Tip: Run `crewx query` or `crewx execute` to start a task.');
+            return;
+        }
+        console.log('Recent Tasks (latest 10)\n');
+        recent.forEach((task, idx) => {
+            const icon = statusIcon(task.status);
+            console.log(`${idx + 1}. ${icon} ${task.id}`);
+            console.log(`   Agent: ${task.agent_id}  Mode: ${task.mode}`);
+            console.log(`   Started: ${new Date(task.started_at).toLocaleString()}`);
+            if (task.completed_at) {
+                console.log(`   Completed: ${new Date(task.completed_at).toLocaleString()}`);
+            }
+            console.log('');
+        });
+        console.log('Tip: Run `crewx result <task-id>` to see full output.');
+        return;
+    }
+    const task = (0, task_db_1.getTask)(taskId);
+    if (!task) {
+        console.error(`Error: Task not found: ${taskId}`);
+        process.exit(1);
+        return;
+    }
+    if (jsonMode) {
+        console.log(JSON.stringify(task, null, 2));
+        return;
+    }
+    if (task.status === 'running') {
+        console.error(`Task ${taskId} is still running.`);
+        console.error(`Use \`crewx kill ${taskId}\` to stop it.`);
+        process.exit(1);
+        return;
+    }
+    if (task.status === 'failed') {
+        console.error(`Task ${taskId} failed: ${task.error ?? 'unknown error'}`);
+        process.exit(1);
+        return;
+    }
+    // Completed (success) — print raw result
+    console.log(task.result ?? '');
+}

package/dist/commands/slack.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Slack files command — crewx slack:files [--thread <thread_ts>] [--list] [--clean]
+ *
+ * Ported 1:1 from packages/cli-bak/src/cli/slack-files.handler.ts.
+ * Implements download/list/clean operations without NestJS or @slack/web-api.
+ * Uses Node.js built-in https and fetch for Slack API calls.
+ */
+/**
+ * Handle `crewx slack` / `crewx slack:files` commands.
+ * Subcommand is determined by flags: --list → list, --clean → clean, default → download.
+ */
+export declare function handleSlack(args: string[]): Promise<void>;