@solidactions/cli 0.7.3 → 1.0.0

package/dist/commands/run-view.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runView = runView;
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("../utils/api");
+async function runView(runId, options) {
+    const config = await (0, api_1.requireConfigWithWorkspace)();
+    try {
+        // Fetch run data (includes session timing)
+        const runResponse = await axios_1.default.get(`${config.host}/api/v1/runs/${runId}`, {
+            headers: (0, api_1.getApiHeaders)(config),
+        });
+        const runData = runResponse.data;
+        // Build timeline
+        const triggeredAt = runData.triggered_at || runData.created_at;
+        const sessionStartedMs = runData.session_started_at_epoch_ms;
+        const sessionCompletedMs = runData.session_completed_at_epoch_ms;
+        const triggeredMs = triggeredAt ? new Date(triggeredAt).getTime() : null;
+        const totalMs = (triggeredMs && sessionCompletedMs) ? sessionCompletedMs - triggeredMs : null;
+        const timeline = {
+            triggered: triggeredAt || null,
+            started: sessionStartedMs ? new Date(sessionStartedMs).toISOString() : null,
+            completed: sessionCompletedMs ? new Date(sessionCompletedMs).toISOString() : null,
+            totalMs,
+        };
+        // --logs: fetch and display raw logs
+        if (options.logs) {
+            const logsResponse = await axios_1.default.get(`${config.host}/api/v1/runs/${runId}/logs`, {
+                headers: (0, api_1.getApiHeaders)(config),
+            });
+            const logData = logsResponse.data.logs || '';
+            // --logs always outputs raw text, even with --json (wrapping logs in JSON is pointless)
+            if (typeof logData === 'string') {
+                console.log(logData);
+            }
+            else {
+                console.log(JSON.stringify(logData, null, 2));
+            }
+            return;
+        }
+        // Fetch steps data
+        const stepsResponse = await axios_1.default.get(`${config.host}/api/v1/runs/${runId}/steps`, {
+            headers: (0, api_1.getApiHeaders)(config),
+        });
+        const stepsData = stepsResponse.data;
+        const flatSteps = flattenSteps(stepsData.workers || []);
+        // --timeline
+        if (options.timeline) {
+            if (options.json) {
+                console.log(JSON.stringify(timeline, null, 2));
+            }
+            else {
+                displayTimeline(runData, timeline);
+            }
+            return;
+        }
+        // --steps
+        if (options.steps) {
+            if (options.json) {
+                console.log(JSON.stringify(flatSteps, null, 2));
+            }
+            else {
+                displayStepsTable(flatSteps);
+            }
+            return;
+        }
+        // Full view
+        // Fetch logs for the full view
+        const logsResponse = await axios_1.default.get(`${config.host}/api/v1/runs/${runId}/logs`, {
+            headers: (0, api_1.getApiHeaders)(config),
+        });
+        if (options.json) {
+            // Full JSON output
+            const output = {
+                id: runData.id,
+                workflow: runData.workflow_name,
+                project: runData.project_name,
+                status: runData.execution_status || runData.status,
+                exitCode: runData.exit_code ?? null,
+                timeline,
+                steps: flatSteps,
+                logs: logsResponse.data.logs || '',
+            };
+            if (runData.output)
+                output.output = runData.output;
+            if (runData.error)
+                output.error = runData.error;
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            // Human-readable output
+            displayFullView(runData, timeline, flatSteps, logsResponse.data);
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            if (error.response.status === 401) {
+                console.error(chalk_1.default.red('Authentication failed. Run "solidactions init <api-key>" to re-configure.'));
+            }
+            else if (error.response.status === 404) {
+                console.error(chalk_1.default.red('Run not found.'));
+            }
+            else {
+                console.error(chalk_1.default.red(`Failed: ${error.response.status}`), error.response.data);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red('Connection failed:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+// ─── Display helpers ───────────────────────────────────────────────────────
+function displayFullView(runData, timeline, steps, logsData) {
+    const status = runData.execution_status || runData.status;
+    const exitCode = runData.exit_code;
+    const statusColor = getStatusColor(status);
+    console.log('');
+    console.log(chalk_1.default.bold(`Run #${runData.id}`) + chalk_1.default.gray(` — ${runData.workflow_name} (${runData.project_name})`));
+    console.log('');
+    // Status line
+    const exitStr = exitCode !== null && exitCode !== undefined ? ` (exit ${exitCode})` : '';
+    console.log(`  Status:    ${statusColor(status)}${chalk_1.default.gray(exitStr)}`);
+    console.log(`  Trigger:   ${chalk_1.default.gray(runData.triggered_by || '-')}`);
+    // Timeline
+    displayTimeline(runData, timeline);
+    // Steps
+    if (steps.length > 0) {
+        console.log('');
+        console.log(chalk_1.default.bold('  Steps:'));
+        displayStepsTable(steps, '    ');
+    }
+    // Output
+    if (runData.output) {
+        console.log('');
+        console.log(chalk_1.default.bold('  Output:'));
+        const outputStr = JSON.stringify(unwrapOutput(runData.output), null, 2);
+        for (const line of outputStr.split('\n')) {
+            console.log(chalk_1.default.gray(`    ${line}`));
+        }
+    }
+    // Error
+    if (runData.error) {
+        console.log('');
+        console.log(chalk_1.default.bold.red('  Error:'));
+        console.log(chalk_1.default.red(`    ${runData.error}`));
+    }
+    // Logs snippet
+    const logs = logsData.logs || '';
+    if (logs && typeof logs === 'string' && logs.trim()) {
+        const logLines = logs.trim().split('\n');
+        const showLines = logLines.length > 10 ? logLines.slice(-10) : logLines;
+        console.log('');
+        console.log(chalk_1.default.bold('  Logs:') + chalk_1.default.gray(logLines.length > 10 ? ` (last 10 of ${logLines.length} lines, use --logs for full)` : ''));
+        for (const line of showLines) {
+            console.log(chalk_1.default.gray(`    ${line}`));
+        }
+    }
+    // Errors from workers
+    const errors = logsData.errors || [];
+    if (errors.length > 0) {
+        console.log('');
+        for (const err of errors) {
+            console.log(chalk_1.default.red(`  Worker ${err.worker}: ${err.error}`));
+        }
+    }
+    console.log('');
+}
+function displayTimeline(runData, timeline) {
+    const formatTs = (iso) => {
+        if (!iso)
+            return '-';
+        const d = new Date(iso);
+        return d.toLocaleString();
+    };
+    console.log(`  Triggered: ${chalk_1.default.gray(formatTs(timeline.triggered))}`);
+    console.log(`  Started:   ${chalk_1.default.gray(formatTs(timeline.started))}`);
+    console.log(`  Completed: ${chalk_1.default.gray(formatTs(timeline.completed))}`);
+    console.log(`  Duration:  ${chalk_1.default.gray(timeline.totalMs ? formatDuration(timeline.totalMs) : '-')}`);
+}
+function displayStepsTable(steps, indent = '  ') {
+    if (steps.length === 0) {
+        console.log(chalk_1.default.gray(`${indent}(no steps)`));
+        return;
+    }
+    console.log(chalk_1.default.gray(`${indent}${'STEP'.padEnd(24)}${'STATUS'.padEnd(12)}${'DURATION'.padEnd(12)}OUTPUT`));
+    console.log(chalk_1.default.gray(`${indent}${'─'.repeat(72)}`));
+    for (const step of steps) {
+        const name = (step.name || '?').padEnd(24);
+        const status = step.completedAt ? 'completed' : step.startedAt ? 'running' : 'pending';
+        const statusColor = getStatusColor(status);
+        const duration = formatDuration(step.durationMs);
+        const output = step.output ? truncate(JSON.stringify(unwrapOutput(step.output)), 40) : '-';
+        console.log(`${indent}${name}${statusColor(status.padEnd(12))}${chalk_1.default.gray(duration.padEnd(12))}${chalk_1.default.gray(output)}`);
+    }
+}
+// ─── Utility ───────────────────────────────────────────────────────────────
+function flattenSteps(workers) {
+    const steps = [];
+    for (const worker of workers) {
+        for (const step of worker.steps || []) {
+            steps.push({
+                name: step.name,
+                startedAt: step.started_at || null,
+                completedAt: step.completed_at || null,
+                durationMs: step.duration_ms ?? null,
+                output: step.output ?? null,
+            });
+        }
+    }
+    return steps;
+}
+function unwrapOutput(output) {
+    if (output && output.__solidactions_serializer === 'superjson' && output.json) {
+        return output.json;
+    }
+    return output;
+}
+function formatDuration(ms) {
+    if (ms === null || ms === undefined)
+        return '-';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 3600000)
+        return `${Math.round(ms / 60000)}m`;
+    return `${Math.round(ms / 3600000)}h`;
+}
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.substring(0, max - 3) + '...';
+}
+function getStatusColor(status) {
+    switch (status?.toLowerCase()) {
+        case 'completed':
+        case 'success':
+            return chalk_1.default.green;
+        case 'running':
+            return chalk_1.default.blue;
+        case 'pending':
+        case 'queued':
+            return chalk_1.default.yellow;
+        case 'failed':
+        case 'error':
+            return chalk_1.default.red;
+        default:
+            return chalk_1.default.gray;
+    }
+}

package/dist/commands/schedule-set.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scheduleSet = scheduleSet;
 const axios_1 = __importDefault(require("axios"));
 const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
 const api_1 = require("../utils/api");
 async function scheduleSet(projectName, cron, options) {
     const config = await (0, api_1.requireConfigWithWorkspace)();
-    console.log(chalk_1.default.blue(`Setting schedule for project "${projectName}"...`));
     // Parse input JSON if provided
     let inputData;
     if (options.input) {
@@ -21,6 +21,50 @@ async function scheduleSet(projectName, cron, options) {
             process.exit(1);
         }
     }
+    // Check for existing schedule on the same workflow
+    if (!options.yes) {
+        try {
+            const listResponse = await axios_1.default.get(`${config.host}/api/v1/projects/${projectName}/schedules`, {
+                headers: (0, api_1.getApiHeaders)(config),
+            });
+            const schedules = listResponse.data.data || listResponse.data || [];
+            const existing = schedules.find((s) => {
+                if (options.workflow) {
+                    return s.workflow_name === options.workflow || s.workflow_slug === options.workflow;
+                }
+                return true; // No workflow specified — any existing schedule is a match
+            });
+            if (existing) {
+                const workflowName = existing.workflow_name || existing.workflow_slug || 'unknown';
+                console.log(chalk_1.default.yellow(`"${workflowName}" already has a schedule: ${existing.cron_expression}`));
+                const confirm = await (0, prompts_1.default)({
+                    type: 'select',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        { title: 'Replace existing schedule', value: 'replace' },
+                        { title: 'Add another schedule', value: 'add' },
+                        { title: 'Cancel', value: 'cancel' },
+                    ],
+                });
+                if (confirm.action === 'cancel' || confirm.action === undefined) {
+                    console.log(chalk_1.default.gray('Cancelled.'));
+                    return;
+                }
+                if (confirm.action === 'replace') {
+                    // Delete the existing schedule first
+                    await axios_1.default.delete(`${config.host}/api/v1/projects/${projectName}/schedules/${existing.id}`, {
+                        headers: (0, api_1.getApiHeaders)(config),
+                    });
+                    console.log(chalk_1.default.gray(`Removed old schedule (${existing.cron_expression}).`));
+                }
+            }
+        }
+        catch {
+            // If we can't check, proceed anyway
+        }
+    }
+    console.log(chalk_1.default.blue(`Setting schedule for project "${projectName}"...`));
     try {
         const payload = {
             cron,

package/dist/commands/{webhooks.js → webhook-list.js}

@@ -21,7 +21,7 @@ async function webhookList(projectName, options = {}) {
             headers: (0, api_1.getApiHeaders)(config),
             params,
         });
-        const webhooks = response.data || [];
+        const webhooks = response.data.data || [];
         if (webhooks.length === 0) {
             console.log(chalk_1.default.yellow('No webhooks found for project "' + projectName + '".'));
             return;
@@ -36,11 +36,11 @@ async function webhookList(projectName, options = {}) {
             console.log(chalk_1.default.gray('-'.repeat(90)));
         }
         for (const webhook of webhooks) {
-            const name = webhook.name || webhook.slug || '?';
-            const url = webhook.url || '?';
+            const name = webhook.workflow_name || webhook.workflow_slug || '?';
+            const url = webhook.webhook_path_url || webhook.webhook_url || '?';
             let line = name.padEnd(30) + chalk_1.default.cyan(url.padEnd(60));
             if (options.showSecrets) {
-                const secret = webhook.secret || '-';
+                const secret = webhook.webhook_secret || '-';
                 line += chalk_1.default.gray(secret);
             }
             console.log(line);

package/dist/commands/workspaces.js

@@ -75,7 +75,7 @@ async function workspaceSet(workspaceId) {
         }
         const workspace = allWorkspaces.find((w) => w.id === workspaceId || w.slug === workspaceId || w.name === workspaceId);
         if (!workspace) {
-            console.error(chalk_1.default.red(`Workspace "${workspaceId}" not found. Run \`solidactions workspaces\` to list available workspaces.`));
+            console.error(chalk_1.default.red(`Workspace "${workspaceId}" not found. Run \`solidactions workspace list\` to list available workspaces.`));
             process.exit(1);
         }
         config.workspaceId = workspace.id;