@griffin-app/griffin-cli 1.0.2 → 1.0.4

package/dist/commands/generate-key.js

@@ -1,4 +1,5 @@
 import { randomBytes } from "node:crypto";
+import { terminal } from "../utils/terminal.js";
 /**
  * Generate a cryptographically secure API key for griffin-runner authentication.
  *
@@ -14,14 +15,19 @@ export async function executeGenerateKey() {
     const keySecret = keyBytes.toString("hex");
     // Add prefix following the pattern: grfn_sk_<secret>
     const apiKey = `grfn_sk_${keySecret}`;
-    console.log("\n✓ Generated API key:\n");
-    console.log(`  ${apiKey}\n`);
-    console.log("⚠️  Store this key securely - it cannot be retrieved later.\n");
-    console.log("To use this key:");
-    console.log("  1. Add it to your runner's AUTH_API_KEYS environment variable:");
-    console.log(`     AUTH_API_KEYS=${apiKey}`);
-    console.log("  2. Or add it to your .griffinrc.json:");
-    console.log(`     { "runner": { "apiToken": "${apiKey}" } }`);
-    console.log("  3. Or pass it via environment variable:");
-    console.log(`     GRIFFIN_API_TOKEN=${apiKey}\n`);
+    terminal.blank();
+    terminal.success("Generated API key:");
+    terminal.blank();
+    terminal.log(`  ${terminal.colors.cyan(apiKey)}`);
+    terminal.blank();
+    terminal.warn("Store this key securely - it cannot be retrieved later.");
+    terminal.blank();
+    terminal.info("To use this key:");
+    terminal.dim("  1. Add it to your runner's AUTH_API_KEYS environment variable:");
+    terminal.dim(`     AUTH_API_KEYS=${apiKey}`);
+    terminal.dim("  2. Or add it to your .griffinrc.json:");
+    terminal.dim(`     { "runner": { "apiToken": "${apiKey}" } }`);
+    terminal.dim("  3. Or pass it via environment variable:");
+    terminal.dim(`     GRIFFIN_API_TOKEN=${apiKey}`);
+    terminal.blank();
 }

package/dist/commands/hub/apply.js

@@ -2,7 +2,8 @@ import { loadState, resolveEnvironment } from "../../core/state.js";
 import { discoverPlans, formatDiscoveryErrors } from "../../core/discovery.js";
 import { computeDiff, formatDiff } from "../../core/diff.js";
 import { applyDiff, formatApplyResult } from "../../core/apply.js";
-import { createSdkClients } from "../../core/sdk.js";
+import { createSdk } from "../../core/sdk.js";
+import { terminal } from "../../utils/terminal.js";
 /**
  * Apply changes to the hub
  */
@@ -14,17 +15,17 @@ export async function executeApply(options) {
         const envName = await resolveEnvironment(options.env);
         // Check if runner is configured
         if (!state.runner?.baseUrl) {
-            console.error("Error: Hub connection not configured.");
-            console.log("Connect with:");
-            console.log("  griffin hub connect --url <url> --token <token>");
-            process.exit(1);
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
         }
-        console.log(`Applying to '${envName}' environment`);
-        console.log("");
+        terminal.info(`Applying to ${terminal.colors.cyan(envName)} environment`);
+        terminal.blank();
         // Create SDK clients
-        const { planApi } = createSdkClients({
-            baseUrl: state.runner.baseUrl,
-            apiToken: state.runner.apiToken || undefined,
+        const sdk = createSdk({
+            baseUrl: state.runner?.baseUrl || "",
+            apiToken: state.runner?.apiToken || "",
         });
         // Discover local plans
         const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
@@ -32,50 +33,70 @@ export async function executeApply(options) {
             "node_modules/**",
             "dist/**",
         ];
+        const spinner = terminal.spinner("Discovering local plans...").start();
         const { plans, errors } = await discoverPlans(discoveryPattern, discoveryIgnore);
         if (errors.length > 0) {
-            console.error(formatDiscoveryErrors(errors));
-            process.exit(1);
+            spinner.fail("Discovery failed");
+            terminal.error(formatDiscoveryErrors(errors));
+            terminal.exit(1);
         }
+        spinner.succeed(`Found ${plans.length} local plan(s)`);
         // Fetch remote plans for this project + environment
-        const response = await planApi.planGet(state.projectId, envName);
-        const remotePlans = response.data.data;
+        const fetchSpinner = terminal
+            .spinner("Fetching remote plans...")
+            .start();
+        const response = await sdk.getPlan({
+            query: {
+                projectId: state.projectId,
+                environment: envName,
+            },
+        });
+        const remotePlans = response?.data?.data;
+        fetchSpinner.succeed(`Found ${remotePlans.length} remote plan(s)`);
         // Compute diff (include deletions if --prune)
         const diff = computeDiff(plans.map((p) => p.plan), remotePlans, { includeDeletions: options.prune || false });
         // Show plan
-        console.log(formatDiff(diff));
-        console.log("");
+        terminal.blank();
+        terminal.log(formatDiff(diff));
+        terminal.blank();
         // Check if there are changes
         if (diff.summary.creates + diff.summary.updates + diff.summary.deletes ===
             0) {
-            console.log("No changes to apply.");
+            terminal.success("No changes to apply.");
             return;
         }
         // Show deletions warning if --prune
         if (options.prune && diff.summary.deletes > 0) {
-            console.warn(`⚠️  --prune will DELETE ${diff.summary.deletes} plan(s) from the hub`);
-            console.log("");
+            terminal.warn(`--prune will DELETE ${diff.summary.deletes} plan(s) from the hub`);
+            terminal.blank();
         }
         // Ask for confirmation unless auto-approved
         if (!options.autoApprove && !options.dryRun) {
-            console.log("Do you want to perform these actions? (yes/no)");
-            // For now, just proceed - in a real implementation, we'd use readline
-            // to get user input
-            console.log("Note: Use --auto-approve flag to skip confirmation");
-            console.log("");
+            const confirmed = await terminal.confirm("Do you want to perform these actions?");
+            if (!confirmed) {
+                terminal.warn("Apply cancelled.");
+                return;
+            }
         }
         // Apply changes with environment injection
-        const result = await applyDiff(diff, planApi, state.projectId, envName, {
+        const applySpinner = terminal.spinner("Applying changes...").start();
+        const result = await applyDiff(diff, sdk, state.projectId, envName, {
             dryRun: options.dryRun,
         });
-        console.log("");
-        console.log(formatApplyResult(result));
+        if (result.success) {
+            applySpinner.succeed("Changes applied successfully");
+        }
+        else {
+            applySpinner.fail("Apply failed");
+        }
+        terminal.blank();
+        terminal.log(formatApplyResult(result));
         if (!result.success) {
-            process.exit(1);
+            terminal.exit(1);
         }
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }

package/dist/commands/hub/connect.js

@@ -1,4 +1,5 @@
 import { loadState, saveState } from "../../core/state.js";
+import { terminal } from "../../utils/terminal.js";
 /**
  * Configure hub connection settings
  */
@@ -11,15 +12,15 @@ export async function executeConnect(options) {
             apiToken: options.token,
         };
         await saveState(state);
-        console.log("✓ Hub connection configured");
-        console.log(`  URL: ${options.url}`);
+        terminal.success("Hub connection configured");
+        terminal.log(`  URL: ${terminal.colors.cyan(options.url)}`);
         if (options.token) {
-            console.log("  API Token: ***");
+            terminal.log(`  API Token: ${terminal.colors.dim("***")}`);
         }
-        console.log("");
+        terminal.blank();
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }

package/dist/commands/hub/plan.js

@@ -1,7 +1,8 @@
 import { loadState, resolveEnvironment } from "../../core/state.js";
 import { discoverPlans, formatDiscoveryErrors } from "../../core/discovery.js";
-import { createSdkClients } from "../../core/sdk.js";
+import { createSdk } from "../../core/sdk.js";
 import { computeDiff, formatDiff, formatDiffJson } from "../../core/diff.js";
+import { terminal } from "../../utils/terminal.js";
 /**
  * Show what changes would be applied
  */
@@ -12,10 +13,10 @@ export async function executePlan(options) {
         // Resolve environment
         const envName = await resolveEnvironment(options.env);
         if (!state.runner?.baseUrl) {
-            console.error("Error: Hub connection not configured.");
-            console.log("Connect with:");
-            console.log("  griffin hub connect --url <url> --token <token>");
-            process.exit(1);
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
         }
         // Discover local plans
         const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
@@ -23,36 +24,49 @@ export async function executePlan(options) {
             "node_modules/**",
             "dist/**",
         ];
+        const spinner = terminal.spinner("Discovering local plans...").start();
         const { plans, errors } = await discoverPlans(discoveryPattern, discoveryIgnore);
         if (errors.length > 0) {
-            console.error(formatDiscoveryErrors(errors));
-            process.exit(1);
+            spinner.fail("Discovery failed");
+            terminal.error(formatDiscoveryErrors(errors));
+            terminal.exit(1);
         }
+        spinner.succeed(`Found ${plans.length} local plan(s)`);
         // Create SDK clients
-        const { planApi } = createSdkClients({
-            baseUrl: state.runner.baseUrl,
-            apiToken: state.runner.apiToken || undefined,
+        const sdk = createSdk({
+            baseUrl: state.runner?.baseUrl || "",
+            apiToken: state.runner?.apiToken || "",
         });
         // Fetch remote plans for this project + environment
-        const response = await planApi.planGet(state.projectId, envName);
-        const remotePlans = response.data.data.map((p) => p);
+        const fetchSpinner = terminal
+            .spinner("Fetching remote plans...")
+            .start();
+        const response = await sdk.getPlan({
+            query: {
+                projectId: state.projectId,
+                environment: envName,
+            },
+        });
+        const remotePlans = response?.data?.data;
+        fetchSpinner.succeed(`Found ${remotePlans.length} remote plan(s)`);
         // Compute diff (no deletions shown by default)
         const diff = computeDiff(plans.map((p) => p.plan), remotePlans, { includeDeletions: false });
+        terminal.blank();
         // Output
         if (options.json) {
-            console.log(formatDiffJson(diff));
+            terminal.log(formatDiffJson(diff));
         }
         else {
-            console.log(formatDiff(diff));
+            terminal.log(formatDiff(diff));
         }
         // Exit with error code if there are changes
         if (diff.summary.creates + diff.summary.updates + diff.summary.deletes >
             0) {
-            process.exit(2); // Exit code 2 indicates changes pending
+            terminal.exit(2); // Exit code 2 indicates changes pending
         }
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }

package/dist/commands/hub/run.js

@@ -1,7 +1,8 @@
 import { loadState, resolveEnvironment } from "../../core/state.js";
-import { createSdkClients } from "../../core/sdk.js";
+import { createSdk } from "../../core/sdk.js";
 import { discoverPlans, formatDiscoveryErrors } from "../../core/discovery.js";
 import { computeDiff } from "../../core/diff.js";
+import { terminal } from "../../utils/terminal.js";
 /**
  * Trigger a plan run on the hub
  */
@@ -12,15 +13,15 @@ export async function executeRun(options) {
         // Resolve environment
         const envName = await resolveEnvironment(options.env);
         if (!state.runner?.baseUrl) {
-            console.error("Error: Hub connection not configured.");
-            console.log("Connect with:");
-            console.log("  griffin hub connect --url <url> --token <token>");
-            process.exit(1);
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
         }
         // Create SDK clients
-        const { planApi, runsApi } = createSdkClients({
-            baseUrl: state.runner.baseUrl,
-            apiToken: state.runner.apiToken || undefined,
+        const sdk = createSdk({
+            baseUrl: state.runner?.baseUrl || "",
+            apiToken: state.runner?.apiToken || "",
         });
         // Discover local plans
         const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
@@ -28,31 +29,42 @@ export async function executeRun(options) {
             "node_modules/**",
             "dist/**",
         ];
+        const spinner = terminal.spinner("Discovering local plans...").start();
         const { plans: discoveredPlans, errors } = await discoverPlans(discoveryPattern, discoveryIgnore);
         if (errors.length > 0) {
-            console.error(formatDiscoveryErrors(errors));
-            process.exit(1);
+            spinner.fail("Discovery failed");
+            terminal.error(formatDiscoveryErrors(errors));
+            terminal.exit(1);
         }
         // Find local plan by name
         const localPlan = discoveredPlans.find((p) => p.plan.name === options.plan);
         if (!localPlan) {
-            console.error(`Error: Plan "${options.plan}" not found locally`);
-            console.error("Available plans:");
+            spinner.fail(`Plan "${options.plan}" not found locally`);
+            terminal.blank();
+            terminal.info("Available plans:");
             for (const p of discoveredPlans) {
-                console.error(`  - ${p.plan.name}`);
+                terminal.dim(`  - ${p.plan.name}`);
             }
-            process.exit(1);
+            terminal.exit(1);
         }
+        spinner.succeed(`Found local plan: ${terminal.colors.cyan(options.plan)}`);
         // Fetch remote plans for this project + environment
-        const response = await planApi.planGet(state.projectId, envName);
-        const remotePlans = response.data.data;
+        const fetchSpinner = terminal.spinner("Checking hub...").start();
+        const response = await sdk.getPlan({
+            query: {
+                projectId: state.projectId,
+                environment: envName,
+            },
+        });
+        const remotePlans = response?.data?.data;
         // Find remote plan by name
         const remotePlan = remotePlans.find((p) => p.name === options.plan);
         if (!remotePlan) {
-            console.error(`Error: Plan "${options.plan}" not found on hub`);
-            console.error("Run 'griffin hub apply' to sync your plans first");
-            process.exit(1);
+            fetchSpinner.fail(`Plan "${options.plan}" not found on hub`);
+            terminal.dim("Run 'griffin hub apply' to sync your plans first");
+            terminal.exit(1);
         }
+        fetchSpinner.succeed("Plan found on hub");
         // Compute diff to check if local plan differs from remote
         const diff = computeDiff([localPlan.plan], [remotePlan], {
             includeDeletions: false,
@@ -60,67 +72,84 @@ export async function executeRun(options) {
         const hasDiff = diff.actions.length > 0 &&
             diff.actions.some((a) => a.type === "update" || a.type === "create");
         if (hasDiff && !options.force) {
-            console.error(`Error: Local plan "${options.plan}" differs from hub`);
-            console.error("");
-            console.error("The plan on the hub is different from your local version.");
-            console.error("Run 'griffin hub apply' to sync, or use --force to run anyway.");
-            process.exit(1);
+            terminal.error(`Local plan "${options.plan}" differs from hub`);
+            terminal.blank();
+            terminal.warn("The plan on the hub is different from your local version.");
+            terminal.dim("Run 'griffin hub apply' to sync, or use --force to run anyway.");
+            terminal.exit(1);
         }
         // Trigger the run
-        console.log(`Triggering run for plan: ${options.plan}`);
-        console.log(`Target environment: ${envName}`);
+        terminal.blank();
+        terminal.info(`Triggering run for plan: ${terminal.colors.cyan(options.plan)}`);
+        terminal.log(`Target environment: ${terminal.colors.cyan(envName)}`);
         if (hasDiff && options.force) {
-            console.log("⚠️  Running with --force (local changes not applied)");
+            terminal.warn("Running with --force (local changes not applied)");
         }
-        const runResponse = await runsApi.runsTriggerPlanIdPost(remotePlan.id, {
-            environment: envName,
+        const triggerSpinner = terminal.spinner("Triggering run...").start();
+        const runResponse = await sdk.postRunsTriggerByPlanId({
+            path: {
+                planId: remotePlan.id,
+            },
+            body: {
+                environment: envName,
+            },
         });
-        console.log(`Run ID: ${runResponse.data.data.id}`);
-        console.log(`Status: ${runResponse.data.data.status}`);
-        console.log(`Started: ${new Date(runResponse.data.data.startedAt).toLocaleString()}`);
+        const run = runResponse?.data?.data;
+        triggerSpinner.succeed("Run triggered");
+        terminal.blank();
+        terminal.log(`Run ID: ${terminal.colors.dim(run.id)}`);
+        terminal.log(`Status: ${terminal.colors.cyan(run.status)}`);
+        terminal.log(`Started: ${terminal.colors.dim(new Date(run.startedAt).toLocaleString())}`);
         // Wait for completion if requested
         if (options.wait) {
-            console.log("");
-            console.log("Waiting for run to complete...");
-            const runId = runResponse.data.data.id;
+            terminal.blank();
+            const waitSpinner = terminal.spinner("Waiting for run to complete...").start();
+            const runId = run.id;
             let completed = false;
             while (!completed) {
                 await new Promise((resolve) => setTimeout(resolve, 2000)); // Poll every 2 seconds
-                const { data: runStatusResponse } = await runsApi.runsIdGet(runId);
-                const run = runStatusResponse.data;
+                const runStatusResponse = await sdk.getRunsById({
+                    path: {
+                        id: runId,
+                    },
+                });
+                const run = runStatusResponse?.data?.data;
                 if (run.status === "completed" || run.status === "failed") {
                     completed = true;
-                    console.log("");
-                    console.log(`✓ Run ${run.status}`);
+                    if (run.success) {
+                        waitSpinner.succeed(`Run ${run.status}`);
+                    }
+                    else {
+                        waitSpinner.fail(`Run ${run.status}`);
+                    }
+                    terminal.blank();
                     if (run.duration_ms) {
-                        console.log(`Duration: ${(run.duration_ms / 1000).toFixed(2)}s`);
+                        terminal.log(`Duration: ${terminal.colors.dim((run.duration_ms / 1000).toFixed(2) + "s")}`);
                     }
                     if (run.success !== undefined) {
-                        console.log(`Success: ${run.success ? "Yes" : "No"}`);
+                        const successText = run.success ? terminal.colors.green("Yes") : terminal.colors.red("No");
+                        terminal.log(`Success: ${successText}`);
                     }
                     if (run.errors && run.errors.length > 0) {
-                        console.log("");
-                        console.log("Errors:");
+                        terminal.blank();
+                        terminal.error("Errors:");
                         for (const error of run.errors) {
-                            console.log(`  - ${error}`);
+                            terminal.dim(`  - ${error}`);
                         }
                     }
                     if (!run.success) {
-                        process.exit(1);
+                        terminal.exit(1);
                     }
                 }
-                else {
-                    process.stdout.write(".");
-                }
             }
         }
         else {
-            console.log("");
-            console.log("Run started. Use 'griffin hub runs' to check progress.");
+            terminal.blank();
+            terminal.dim("Run started. Use 'griffin hub runs' to check progress.");
         }
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }

package/dist/commands/hub/runs.js

@@ -1,5 +1,6 @@
 import { loadState } from "../../core/state.js";
-import { createSdkClients } from "../../core/sdk.js";
+import { createSdk } from "../../core/sdk.js";
+import { terminal } from "../../utils/terminal.js";
 /**
  * Show recent runs from the hub
  */
@@ -8,55 +9,94 @@ export async function executeRuns(options) {
         // Load state
         const state = await loadState();
         if (!state.runner?.baseUrl) {
-            console.error("Error: Hub connection not configured.");
-            console.log("Connect with:");
-            console.log("  griffin hub connect --url <url> --token <token>");
-            process.exit(1);
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
         }
         // Create SDK clients
-        const { runsApi } = createSdkClients({
+        const sdk = createSdk({
             baseUrl: state.runner.baseUrl,
             apiToken: state.runner.apiToken || undefined,
         });
-        console.log(`Hub: ${state.runner.baseUrl}`);
-        console.log("");
+        terminal.info(`Hub: ${terminal.colors.cyan(state.runner.baseUrl)}`);
+        terminal.blank();
         // Get recent runs
         const limit = options.limit || 10;
-        const response = await runsApi.runsGet(options.plan, undefined, limit, 0);
-        const runs = response.data;
-        if (runs.total === 0) {
-            console.log("No runs found.");
+        const spinner = terminal.spinner("Fetching runs...").start();
+        const response = await sdk.getRuns({
+            query: {
+                planId: options.plan,
+                limit: limit,
+                offset: 0,
+            },
+        });
+        const runsData = response?.data;
+        if (!runsData || runsData.total === 0) {
+            spinner.info("No runs found.");
             return;
         }
-        console.log(`Recent runs (${runs.total} total):`);
-        console.log("");
-        for (const run of runs.runs) {
-            const statusIcon = getStatusIcon(run.status, run.success);
-            const duration = run.duration_ms
-                ? ` (${(run.duration_ms / 1000).toFixed(2)}s)`
-                : "";
-            console.log(`${statusIcon} ${run.planName}`);
-            console.log(`  ID: ${run.id}`);
-            console.log(`  Status: ${run.status}${duration}`);
-            console.log(`  Started: ${new Date(run.startedAt).toLocaleString()}`);
-            if (run.completedAt) {
-                console.log(`  Completed: ${new Date(run.completedAt).toLocaleString()}`);
+        if (!Array.isArray(runsData.data)) {
+            spinner.fail("Invalid response format");
+            terminal.error(`Expected data array but got: ${typeof runsData.data}`);
+            terminal.exit(1);
+        }
+        spinner.succeed(`Found ${runsData.total} run(s)`);
+        terminal.blank();
+        // Create table
+        const table = terminal.table({
+            head: ["Status", "Plan", "Duration", "Started"],
+        });
+        for (const run of runsData.data) {
+            try {
+                const statusIcon = getStatusIcon(run.status, run.success);
+                const duration = run.duration_ms
+                    ? `${(run.duration_ms / 1000).toFixed(2)}s`
+                    : "-";
+                const started = new Date(run.startedAt).toLocaleString();
+                table.push([
+                    statusIcon,
+                    run.planId || "-",
+                    duration,
+                    started,
+                ]);
             }
-            if (run.errors && run.errors.length > 0) {
-                console.log(`  Errors:`);
-                for (const error of run.errors.slice(0, 3)) {
-                    console.log(`    - ${error}`);
-                }
-                if (run.errors.length > 3) {
-                    console.log(`    ... and ${run.errors.length - 3} more`);
+            catch (error) {
+                terminal.error(`Error processing run ${run.id}: ${error.message}`);
+            }
+        }
+        try {
+            terminal.log(table.toString());
+        }
+        catch (error) {
+            terminal.error(`Error rendering table: ${error.message}`);
+            terminal.error(error.stack || "");
+            terminal.exit(1);
+        }
+        // Show detailed errors if any
+        const runsWithErrors = runsData.data.filter((run) => Array.isArray(run.errors) && run.errors.length > 0);
+        if (runsWithErrors.length > 0) {
+            terminal.blank();
+            terminal.warn("Runs with errors:");
+            terminal.blank();
+            for (const run of runsWithErrors) {
+                terminal.log(`${terminal.colors.red("✗")} ${terminal.colors.cyan(run.planId || run.id)}`);
+                if (Array.isArray(run.errors) && run.errors.length > 0) {
+                    const errorsToShow = run.errors.slice(0, 3);
+                    for (const error of errorsToShow) {
+                        terminal.dim(`  - ${String(error)}`);
+                    }
+                    if (run.errors.length > 3) {
+                        terminal.dim(`  ... and ${run.errors.length - 3} more`);
+                    }
                 }
+                terminal.blank();
             }
-            console.log("");
         }
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        terminal.error(error.message);
+        terminal.exit(1);
     }
 }
 function getStatusIcon(status, success) {
@@ -66,9 +106,9 @@ function getStatusIcon(status, success) {
         case "running":
             return "🏃";
         case "completed":
-            return success ? "✓" : "✗";
+            return success ? "✅" : "❌";
         case "failed":
-            return "✗";
+            return "❌";
         default:
             return "•";
     }