@actiondock/cli 2.0.8 → 2.0.10

package/src/commands/profile.ts

@@ -13,6 +13,13 @@ import {
   useProfile,
 } from "@actiondock/core";
 import { Command } from "commander";
+import {
+  ArgumentError,
+  CliError,
+  ExecutionError,
+  getEffectiveOptions,
+  renderResult,
+} from "@actiondock/runtime-cli";
 import { resolveIntent } from "../utils/filter";
 
 export function registerProfileCommands(program: Command): void {
@@ -26,12 +33,17 @@ export function registerProfileCommands(program: Command): void {
     .description("List all configured profiles")
     .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
     .option("--reveal, --show-secrets", "Reveal plain text values for tokens")
+    .option("--fallback", "Enable fallback to full list when no items match intent")
     .option("--no-fallback", "Disable fallback to full list when no items match intent")
     .option("--json", "Output as JSON")
-    .action((patterns, options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action((patterns, rawOptions, cmd) => {
       try {
+        const options = getEffectiveOptions(rawOptions, cmd);
         const effectiveIntent = resolveIntent(options.intent, patterns);
-        const shouldFallback = options.fallback !== false;
+        const isMachine = Boolean(options.json || options.envelope);
+        const fallbackExplicit = options.fallback === true || (Array.isArray(process.argv) && process.argv.includes("--fallback"));
+        const shouldFallback = isMachine ? fallbackExplicit : options.fallback !== false;
         const reveal = Boolean(options.reveal || options.showSecrets);
 
         const list = listProfiles();
@@ -56,42 +68,53 @@ export function registerProfileCommands(program: Command): void {
           shouldFallback
         );
 
-        if (options.json) {
-          console.log(JSON.stringify(filterRes.items, null, 2));
-        } else {
-          console.log("ActionDock Execution Profiles:\n");
-          if (filterRes.isFallback && effectiveIntent) {
-            console.log(`(No profiles matched intent '${effectiveIntent}', showing all profiles)\n`);
-          }
-          for (const item of filterRes.items) {
-            const currentMarker = item.isCurrent ? "* " : "  ";
-            let tokenInfo = "";
-            if (item.tokenSource === "tokenEnv") {
-              tokenInfo = ` [token: env(${item.tokenEnv})]`;
-            } else if (item.tokenSource === "profileEnv") {
-              tokenInfo = ` [token: env(ACTIONDOCK_${toSnakeUpperCase(item.name)}_TOKEN)]`;
-            } else if (item.tokenSource === "profile") {
-              tokenInfo = ` [token: stored in profile]`;
-            } else if (item.tokenSource === "globalEnv") {
-              tokenInfo = ` [token: env(ACTIONDOCK_TOKEN)]`;
-            }
+        if (filterRes.isFallback && isMachine) {
+          renderResult(
+            { items: filterRes.items, isFallback: true, matchedCount: 0 },
+            { json: options.json, envelope: options.envelope }
+          );
+          return;
+        }
 
-            if (reveal && item.token) {
-              tokenInfo += ` = ${item.token}`;
+        renderResult(filterRes.items, {
+          json: options.json,
+          envelope: options.envelope,
+          humanFormatter: () => {
+            const lines = ["ActionDock Execution Profiles:\n"];
+            if (filterRes.isFallback && effectiveIntent) {
+              lines.push(`(No profiles matched intent '${effectiveIntent}', showing all profiles)\n`);
             }
+            for (const item of filterRes.items) {
+              const currentMarker = item.isCurrent ? "* " : "  ";
+              let tokenInfo = "";
+              if (item.tokenSource === "tokenEnv") {
+                tokenInfo = ` [token: env(${item.tokenEnv})]`;
+              } else if (item.tokenSource === "profileEnv") {
+                tokenInfo = ` [token: env(ACTIONDOCK_${toSnakeUpperCase(item.name)}_TOKEN)]`;
+              } else if (item.tokenSource === "profile") {
+                tokenInfo = ` [token: stored in profile]`;
+              } else if (item.tokenSource === "globalEnv") {
+                tokenInfo = ` [token: env(ACTIONDOCK_TOKEN)]`;
+              }
+
+              if (reveal && item.token) {
+                tokenInfo += ` = ${item.token}`;
+              }
 
-            const desc = item.description ? ` - ${item.description}` : "";
-            console.log(
-              `${currentMarker}${item.name.padEnd(20)} ${item.serverUrl}${tokenInfo}${desc}`
+              const desc = item.description ? ` - ${item.description}` : "";
+              lines.push(
+                `${currentMarker}${item.name.padEnd(20)} ${item.serverUrl}${tokenInfo}${desc}`
+              );
+            }
+            lines.push(
+              "\nUse 'ad profile use <name>' to switch or 'ad run <action> --profile <name>' to execute on a specific target."
             );
-          }
-          console.log(
-            "\nUse 'ad profile use <name>' to switch or 'ad run <action> --profile <name>' to execute on a specific target."
-          );
-        }
+            return lines.join("\n");
+          },
+        });
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof ArgumentError || err instanceof CliError) throw err;
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -118,8 +141,7 @@ export function registerProfileCommands(program: Command): void {
         });
         console.log(`[OK] Profile '${name}' configured for server: ${options.server}`);
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -132,8 +154,7 @@ export function registerProfileCommands(program: Command): void {
         useProfile(name);
         console.log(`[OK] Active profile switched to '${name}'`);
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -143,16 +164,17 @@ export function registerProfileCommands(program: Command): void {
     .description("Display details of a profile (defaults to active profile)")
     .option("--reveal, --show-secrets", "Reveal plain text values for tokens")
     .option("--json", "Output as JSON")
-    .action((name, options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action((name, rawOptions, cmd) => {
       try {
+        const options = getEffectiveOptions(rawOptions, cmd);
         const config = loadProfiles();
         const targetName = name || config.currentProfile || "local";
         const entry = getProfile(targetName);
         const reveal = Boolean(options.reveal || options.showSecrets);
 
         if (!entry && targetName !== "local") {
-          console.error(`Error: Profile '${targetName}' not found.`);
-          process.exit(1);
+          throw new ArgumentError(`Profile '${targetName}' not found.`);
         }
 
         const resolved = resolveProfileToken(targetName, entry);
@@ -171,32 +193,38 @@ export function registerProfileCommands(program: Command): void {
           description: entry?.description || "",
         };
 
-        if (options.json) {
-          console.log(JSON.stringify(data, null, 2));
-        } else {
-          console.log(`Profile:      ${data.name}${data.isCurrent ? " (Active)" : ""}`);
-          console.log(`Server URL:   ${data.serverUrl}`);
-          let sourceDetail = "None";
-          if (data.tokenSource === "tokenEnv") {
-            sourceDetail = `Environment Variable ($${data.tokenEnv})`;
-          } else if (data.tokenSource === "profileEnv") {
-            sourceDetail = `Profile Environment Variable ($ACTIONDOCK_${toSnakeUpperCase(data.name)}_TOKEN)`;
-          } else if (data.tokenSource === "profile") {
-            sourceDetail = "Stored in profiles.json (Deprecated)";
-          } else if (data.tokenSource === "globalEnv") {
-            sourceDetail = "Global Environment Variable ($ACTIONDOCK_TOKEN)";
-          }
-          console.log(`Auth Source:  ${sourceDetail}`);
-          if (data.tokenConfigured) {
-            console.log(`Token Value:  ${data.token}`);
-          }
-          if (data.description) {
-            console.log(`Description:  ${data.description}`);
-          }
-        }
+        renderResult(data, {
+          json: options.json,
+          envelope: options.envelope,
+          humanFormatter: () => {
+            const lines: string[] = [];
+            lines.push(`Profile:      ${data.name}${data.isCurrent ? " (Active)" : ""}`);
+            lines.push(`Server URL:   ${data.serverUrl}`);
+            let sourceDetail = "None";
+            if (data.tokenSource === "tokenEnv") {
+              sourceDetail = `Environment Variable ($${data.tokenEnv})`;
+            } else if (data.tokenSource === "profileEnv") {
+              sourceDetail = `Profile Environment Variable ($ACTIONDOCK_${toSnakeUpperCase(data.name)}_TOKEN)`;
+            } else if (data.tokenSource === "profile") {
+              sourceDetail = "Stored in profiles.json (Deprecated)";
+            } else if (data.tokenSource === "globalEnv") {
+              sourceDetail = "Global Environment Variable ($ACTIONDOCK_TOKEN)";
+            }
+            lines.push(`Auth Source:  ${sourceDetail}`);
+            if (data.tokenConfigured) {
+              lines.push(`Token Value:  ${data.token}`);
+            }
+            if (data.description) {
+              lines.push(`Description:  ${data.description}`);
+            }
+            return lines.join("\n");
+          },
+        });
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof ArgumentError || err instanceof CliError) {
+          throw err;
+        }
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -208,18 +236,18 @@ export function registerProfileCommands(program: Command): void {
     .action((name) => {
       try {
         if (name === "local") {
-          console.error("Error: Cannot remove built-in 'local' profile");
-          process.exit(1);
+          throw new ExecutionError("Cannot remove built-in 'local' profile");
         }
         const removed = removeProfile(name);
         if (!removed) {
-          console.error(`Error: Profile '${name}' not found`);
-          process.exit(1);
+          throw new ExecutionError(`Profile '${name}' not found`);
         }
         console.log(`[OK] Profile '${name}' removed`);
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof CliError) {
+          throw err;
+        }
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -228,36 +256,41 @@ export function registerProfileCommands(program: Command): void {
     .command("test [name]")
     .description("Test connection latency and health of a profile")
     .option("--json", "Output as JSON")
-    .action(async (name, options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (name, rawOptions, cmd) => {
       try {
+        const options = getEffectiveOptions(rawOptions, cmd);
         const target = resolveTarget({ profile: name });
         if (target.type === "local") {
-          if (options.json) {
-            console.log(JSON.stringify({ ok: true, type: "local", message: "Local execution" }, null, 2));
-          } else {
-            console.log(`Target profile '${target.profileName || "local"}' is local (runs in local runtime).`);
-          }
+          renderResult(
+            { ok: true, type: "local", message: "Local execution" },
+            {
+              json: options.json,
+              envelope: options.envelope,
+              humanFormatter: () =>
+                `Target profile '${target.profileName || "local"}' is local (runs in local runtime).`,
+            }
+          );
           return;
         }
 
         const health = await checkRemoteHealth(target.serverUrl!, target.token);
-        if (options.json) {
-          console.log(JSON.stringify(health, null, 2));
-        } else {
-          if (health.ok) {
-            console.log(
-              `[OK] Connected to ${target.serverUrl} (${health.latencyMs}ms) - Version: ${health.version}, Status: ${health.status}`
-            );
-          } else {
-            console.error(
-              `[FAIL] Connection to ${target.serverUrl} failed (${health.latencyMs}ms): ${health.error}`
-            );
-            process.exit(1);
-          }
+        renderResult(health, {
+          json: options.json,
+          envelope: options.envelope,
+          humanFormatter: () => {
+            if (health.ok) {
+              return `[OK] Connected to ${target.serverUrl} (${health.latencyMs}ms) - Version: ${health.version}, Status: ${health.status}`;
+            }
+            return `[FAIL] Connection to ${target.serverUrl} failed (${health.latencyMs}ms): ${health.error}`;
+          },
+        });
+        if (!health.ok) {
+          process.exitCode = 1;
         }
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof ArgumentError || err instanceof CliError) throw err;
+        throw new ExecutionError(err.message);
       }
     });
 }

package/src/commands/runs.ts

@@ -13,6 +13,7 @@ import {
   resolveTarget,
 } from "@actiondock/core";
 import { Command } from "commander";
+import { ArgumentError, CliError, ExecutionError, getEffectiveOptions, renderResult } from "@actiondock/runtime-cli";
 import { resolveIntent } from "../utils/filter";
 
 function printRunRecord(run: any): void {
@@ -55,12 +56,16 @@ export function registerRunsCommands(program: Command): void {
     .option("-s, --server <url>", "Remote server URL")
     .option("-t, --token <token>", "Auth token for remote server")
     .option("--no-fallback", "Disable fallback to full list when no items match intent")
+    .option("--data-dir <path>", "Custom database storage directory")
     .option("--json", "Output as JSON")
-    .action(async (patterns, options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (patterns, rawOptions, cmd) => {
       try {
+        const options = getEffectiveOptions(rawOptions, cmd);
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const shouldFallback = options.fallback !== false;
         const limit = Number.parseInt(options.limit, 10) || 20;
+        const isMachine = Boolean(options.json || options.envelope);
 
         const target = resolveTarget({
           profile: options.profile,
@@ -75,8 +80,8 @@ export function registerRunsCommands(program: Command): void {
             intent: effectiveIntent,
             limit,
           });
-          if (options.json) {
-            console.log(JSON.stringify(res.items, null, 2));
+          if (isMachine) {
+            renderResult(res.items, { json: options.json, envelope: options.envelope });
             return;
           }
           console.log(
@@ -100,13 +105,15 @@ export function registerRunsCommands(program: Command): void {
           : findProjectRoot();
 
         if (options.package && !targetRoot) {
-          console.error(`Error: Package '${options.package}' not found in linked packages or path`);
-          process.exit(1);
+          throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
         }
 
         if (targetRoot) {
           const projConfig = loadProjectConfig(targetRoot);
-          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+          const storage = createStorage(projConfig.id, {
+            projectRoot: targetRoot,
+            dataDir: options.dataDir,
+          });
           const records = storage.listRuns({
             actionId: options.action,
             limit,
@@ -120,8 +127,8 @@ export function registerRunsCommands(program: Command): void {
             shouldFallback
           );
 
-          if (options.json) {
-            console.log(JSON.stringify(filterRes.items, null, 2));
+          if (isMachine) {
+            renderResult(filterRes.items, { json: options.json, envelope: options.envelope });
           } else {
             console.log(`Execution Runs in ${projConfig.id} (${filterRes.items.length}):\n`);
             if (filterRes.isFallback && effectiveIntent) {
@@ -144,6 +151,10 @@ export function registerRunsCommands(program: Command): void {
         // Outside project: List recent runs across all linked packages
         const linkedList = listLinkedPackages();
         if (linkedList.length === 0) {
+          if (isMachine) {
+            renderResult([], { json: options.json, envelope: options.envelope });
+            return;
+          }
           console.log("No ActionDock project in current directory, and no packages linked.");
           console.log("Run 'ad link' inside an Action package to register it.");
           return;
@@ -154,7 +165,10 @@ export function registerRunsCommands(program: Command): void {
           if (!existsSync(pkg.path)) continue;
           try {
             const projConfig = loadProjectConfig(pkg.path);
-            const storage = createStorage(projConfig.id, { projectRoot: pkg.path });
+            const storage = createStorage(projConfig.id, {
+              projectRoot: pkg.path,
+              dataDir: options.dataDir,
+            });
             const records = storage.listRuns({
               actionId: options.action,
               limit,
@@ -179,8 +193,8 @@ export function registerRunsCommands(program: Command): void {
           shouldFallback
         );
 
-        if (options.json) {
-          console.log(JSON.stringify(filterRes.items, null, 2));
+        if (isMachine) {
+          renderResult(filterRes.items, { json: options.json, envelope: options.envelope });
         } else {
           console.log(`Execution Runs across Linked Packages (${filterRes.items.length}):\n`);
           if (filterRes.isFallback && effectiveIntent) {
@@ -198,8 +212,10 @@ export function registerRunsCommands(program: Command): void {
           }
         }
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof CliError) {
+          throw err;
+        }
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -211,9 +227,13 @@ export function registerRunsCommands(program: Command): void {
     .option("-p, --profile <name>", "Query run against a specific profile")
     .option("-s, --server <url>", "Remote server URL")
     .option("-t, --token <token>", "Auth token for remote server")
+    .option("--data-dir <path>", "Custom database storage directory")
     .option("--json", "Output as JSON")
-    .action(async (id, options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (id, rawOptions, cmd) => {
       let target;
+      const options = getEffectiveOptions(rawOptions, cmd);
+      const isMachine = Boolean(options.json || options.envelope);
       try {
         target = resolveTarget({
           profile: options.profile,
@@ -221,22 +241,20 @@ export function registerRunsCommands(program: Command): void {
           token: options.token,
         });
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
 
       if (target.type === "remote") {
         try {
           const run = await fetchRemoteRun(target.serverUrl!, id, target.token);
-          if (options.json) {
-            console.log(JSON.stringify(run, null, 2));
+          if (isMachine) {
+            renderResult(run, { json: options.json, envelope: options.envelope });
           } else {
             printRunRecord(run);
           }
           return;
         } catch (err: any) {
-          console.error(`Error: ${err.message}`);
-          process.exit(1);
+          throw new ExecutionError(err.message);
         }
       }
 
@@ -247,11 +265,13 @@ export function registerRunsCommands(program: Command): void {
         if (options.package) {
           const targetRoot = resolvePackageRoot(options.package);
           if (!targetRoot) {
-            console.error(`Error: Package '${options.package}' not found in linked packages or path`);
-            process.exit(1);
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
           }
           const projConfig = loadProjectConfig(targetRoot);
-          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+          const storage = createStorage(projConfig.id, {
+            projectRoot: targetRoot,
+            dataDir: options.dataDir,
+          });
           foundRun = storage.getRun(id);
           storage.close();
           if (foundRun && !foundRun.packageId) {
@@ -263,7 +283,10 @@ export function registerRunsCommands(program: Command): void {
           if (currentRoot) {
             try {
               const projConfig = loadProjectConfig(currentRoot);
-              const storage = createStorage(projConfig.id, { projectRoot: currentRoot });
+              const storage = createStorage(projConfig.id, {
+                projectRoot: currentRoot,
+                dataDir: options.dataDir,
+              });
               foundRun = storage.getRun(id);
               storage.close();
               if (foundRun && !foundRun.packageId) {
@@ -279,7 +302,10 @@ export function registerRunsCommands(program: Command): void {
               if (!existsSync(pkg.path)) continue;
               try {
                 const projConfig = loadProjectConfig(pkg.path);
-                const storage = createStorage(projConfig.id, { projectRoot: pkg.path });
+                const storage = createStorage(projConfig.id, {
+                  projectRoot: pkg.path,
+                  dataDir: options.dataDir,
+                });
                 const r = storage.getRun(id);
                 storage.close();
                 if (r) {
@@ -292,18 +318,19 @@ export function registerRunsCommands(program: Command): void {
         }
 
         if (!foundRun) {
-          console.error(`Error: Run record '${id}' not found in current project or any linked packages`);
-          process.exit(1);
+          throw new ExecutionError(`Run record '${id}' not found in current project or any linked packages`);
         }
 
-        if (options.json) {
-          console.log(JSON.stringify(foundRun, null, 2));
+        if (isMachine) {
+          renderResult(foundRun, { json: options.json, envelope: options.envelope });
         } else {
           printRunRecord(foundRun);
         }
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof CliError) {
+          throw err;
+        }
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -316,8 +343,11 @@ export function registerRunsCommands(program: Command): void {
     .option("-t, --token <token>", "Auth token for remote server")
     .option("-r, --reason <reason>", "Reason for cancellation")
     .option("--json", "Output as JSON")
-    .action(async (id, options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (id, rawOptions, cmd) => {
       let target;
+      const options = getEffectiveOptions(rawOptions, cmd);
+      const isMachine = Boolean(options.json || options.envelope);
       try {
         target = resolveTarget({
           profile: options.profile,
@@ -325,15 +355,13 @@ export function registerRunsCommands(program: Command): void {
           token: options.token,
         });
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
 
       if (target.type === "local") {
-        console.error(
-          "Error: 'ad runs cancel' is only supported for remote execution targets. Use --profile <name> or --server <url>."
+        throw new ArgumentError(
+          "'ad runs cancel' is only supported for remote execution targets. Use --profile <name> or --server <url>."
         );
-        process.exit(1);
       }
 
       try {
@@ -343,14 +371,13 @@ export function registerRunsCommands(program: Command): void {
           target.token,
           options.reason
         );
-        if (options.json) {
-          console.log(JSON.stringify(result, null, 2));
+        if (isMachine) {
+          renderResult(result, { json: options.json, envelope: options.envelope });
         } else {
           console.log(`Run '${id}' cancellation requested (Status: ${result.status}).`);
         }
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        throw new ExecutionError(err.message);
       }
     });
 
@@ -363,9 +390,13 @@ export function registerRunsCommands(program: Command): void {
     .option("-p, --profile <name>", "Target profile")
     .option("-s, --server <url>", "Remote server URL")
     .option("-t, --token <token>", "Auth token for remote server")
+    .option("--data-dir <path>", "Custom database storage directory")
     .option("--json", "Output as JSON")
-    .action(async (options) => {
+    .option("--envelope", "Wrap JSON output in standard envelope")
+    .action(async (rawOptions, cmd) => {
       try {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const isMachine = Boolean(options.json || options.envelope);
         const target = resolveTarget({
           profile: options.profile,
           server: options.server,
@@ -377,8 +408,8 @@ export function registerRunsCommands(program: Command): void {
             packageId: options.package,
             actionId: options.action,
           });
-          if (options.json) {
-            console.log(JSON.stringify(res, null, 2));
+          if (isMachine) {
+            renderResult(res, { json: options.json, envelope: options.envelope });
           } else {
             console.log(`Cleared ${res.clearedCount} execution run(s) on remote server.`);
           }
@@ -389,20 +420,32 @@ export function registerRunsCommands(program: Command): void {
           ? resolvePackageRoot(options.package)
           : findProjectRoot();
 
+        if (options.package && !targetRoot) {
+          throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+
         if (targetRoot) {
           const projConfig = loadProjectConfig(targetRoot);
-          const storage = createStorage(projConfig.id, { projectRoot: targetRoot });
+          const storage = createStorage(projConfig.id, {
+            projectRoot: targetRoot,
+            dataDir: options.dataDir,
+          });
           const count = storage.clearRuns({ actionId: options.action });
           storage.close();
-          if (options.json) {
-            console.log(JSON.stringify({ ok: true, clearedCount: count }, null, 2));
+          if (isMachine) {
+            renderResult({ ok: true, clearedCount: count, packageId: projConfig.id }, { json: options.json, envelope: options.envelope });
           } else {
             console.log(`Cleared ${count} execution run(s) in package '${projConfig.id}'.`);
           }
+          return;
         }
+
+        throw new ArgumentError(
+          "Not in an ActionDock project. Please specify -P, --package <id> or cd into a project directory."
+        );
       } catch (err: any) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+        if (err instanceof CliError) throw err;
+        throw new ExecutionError(err.message);
       }
     });
 }