@imbrace/cli 0.1.0

package/dist/commands/workflow/delete.js

@@ -0,0 +1,40 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { confirm, input } from "@inquirer/prompts";
+import { apiRequest } from "../../http.js";
+export default class WorkflowDelete extends BaseCommand {
+    static description = "Delete a workflow";
+    static examples = [
+        "imbrace workflow delete <flowId> --yes",
+        "imbrace workflow delete <flowId> --yes --json",
+    ];
+    static args = {
+        id: Args.string({ description: "Workflow ID" }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: "y", description: "Skip confirmation" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowDelete);
+        const id = args.id ?? (flags.json ? this.error("ID is required") : await input({ message: "Workflow ID:" }));
+        if (!flags.yes && !flags.json) {
+            const ok = await confirm({ message: `Delete workflow ${id}?`, default: false });
+            if (!ok) {
+                this.log("Cancelled.");
+                return;
+            }
+        }
+        try {
+            const res = await apiRequest(`/workflow/${id}`, { method: "DELETE" });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${res.message}\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/get.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WorkflowGet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/get.js

@@ -0,0 +1,54 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { apiRequest } from "../../http.js";
+export default class WorkflowGet extends BaseCommand {
+    static description = "Get details of a workflow (including node tree)";
+    static examples = [
+        "imbrace workflow get <flowId>",
+        "imbrace workflow get <flowId> --json",
+    ];
+    static args = {
+        id: Args.string({ description: "Workflow ID" }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowGet);
+        const id = args.id ?? (flags.json ? this.error("ID is required") : await input({ message: "Workflow ID:" }));
+        try {
+            const res = await apiRequest(`/workflow/${id}`);
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const f = res.data || {};
+            const v = f.version || {};
+            this.log(`\n  ID:           ${f.id || ""}`);
+            this.log(`  Name:         ${v.displayName || ""}`);
+            this.log(`  Status:       ${f.status || ""}`);
+            this.log(`  Project ID:   ${f.projectId || ""}`);
+            this.log(`  Created:      ${f.created || ""}`);
+            this.log(`  Updated:      ${f.updated || ""}`);
+            // Print node tree
+            this.log(`\n  Node tree:`);
+            let cur = v.trigger;
+            let depth = 0;
+            while (cur && depth < 20) {
+                const indent = "    ".repeat(depth);
+                const piece = cur.settings?.pieceName || "";
+                const action = cur.settings?.actionName || cur.settings?.triggerName || "";
+                this.log(`  ${indent}${cur.name || "(unnamed)"} [${cur.type}] ${piece}${action ? ` :: ${action}` : ""}`);
+                cur = cur.nextAction;
+                depth++;
+            }
+            if (!v.trigger)
+                this.log("    (empty — no trigger set)");
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/list.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WorkflowList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/list.js

@@ -0,0 +1,36 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { apiRequest } from "../../http.js";
+export default class WorkflowList extends BaseCommand {
+    static description = "List all workflows (Activepieces flows)";
+    static examples = [
+        "imbrace workflow list",
+        "imbrace workflow list --json",
+    ];
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowList);
+        try {
+            const res = await apiRequest("/workflow/list");
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n  Found ${res.count} workflow(s):\n`);
+            this.log("  ID                       NAME                                 STATUS");
+            this.log("  ────────────────────────────────────────────────────────────────────");
+            for (const flow of res.data || []) {
+                const id = (flow.id || "").padEnd(24);
+                const name = (flow.version?.displayName || "").padEnd(36);
+                const status = flow.status || "";
+                this.log(`  ${id} ${name} ${status}`);
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/node/add.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowNodeAdd extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        flowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        piece: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "trigger-name": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "action-name": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        after: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "display-name": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/node/add.js

@@ -0,0 +1,72 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowNodeAdd extends BaseCommand {
+    static description = "Add a trigger or action node to a workflow";
+    static examples = [
+        'imbrace workflow node add <flowId> --type trigger --piece webhook --trigger-name catch_webhook --json',
+        'imbrace workflow node add <flowId> --type action --piece slack --action-name send_channel_message --input \'{"channel":"C1","text":"hi"}\' --json',
+        'imbrace workflow node add <flowId> --type action --piece ai-connector --action-name ask --after step_1 --input \'{"prompt":"hello","modelName":"gpt-4o"}\' --json',
+    ];
+    static args = {
+        flowId: Args.string({ description: "Workflow ID", required: true }),
+    };
+    static flags = {
+        type: Flags.string({ description: "Node type", options: ["trigger", "action"], required: true }),
+        piece: Flags.string({ description: "Piece name (e.g. 'slack' or '@activepieces/piece-slack')", required: true }),
+        "trigger-name": Flags.string({ description: "Trigger identifier (when --type trigger)" }),
+        "action-name": Flags.string({ description: "Action identifier (when --type action)" }),
+        after: Flags.string({ description: "Place new action after this step name (default: end of chain)" }),
+        name: Flags.string({ description: "Override auto-generated step_N name" }),
+        "display-name": Flags.string({ description: "UI display name" }),
+        input: Flags.string({ description: "JSON string with field values (e.g. '{\"channel\":\"C1\",\"text\":\"hi\"}')" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowNodeAdd);
+        if (flags.type === "trigger" && !flags["trigger-name"]) {
+            this.error("--trigger-name is required when --type=trigger");
+        }
+        if (flags.type === "action" && !flags["action-name"]) {
+            this.error("--action-name is required when --type=action");
+        }
+        let parsedInput = {};
+        if (flags.input) {
+            try {
+                parsedInput = JSON.parse(flags.input);
+            }
+            catch (e) {
+                this.error(`--input is not valid JSON: ${e.message}`);
+            }
+        }
+        const body = {
+            type: flags.type,
+            piece: flags.piece,
+            input: parsedInput,
+        };
+        if (flags["trigger-name"])
+            body.triggerName = flags["trigger-name"];
+        if (flags["action-name"])
+            body.actionName = flags["action-name"];
+        if (flags.after)
+            body.after = flags.after;
+        if (flags.name)
+            body.name = flags.name;
+        if (flags["display-name"])
+            body.displayName = flags["display-name"];
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/nodes`, { method: "POST", body });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${res.message}`);
+            if (res.data?.stepName)
+                this.log(`   Step: ${res.data.stepName} (after ${res.data.parentStep})`);
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/node/delete.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowNodeDelete extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        flowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        nodeName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/node/delete.js

@@ -0,0 +1,40 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { confirm } from "@inquirer/prompts";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowNodeDelete extends BaseCommand {
+    static description = "Delete an action node from a workflow (cannot delete trigger — replace it via `node add --type trigger`)";
+    static examples = [
+        "imbrace workflow node delete <flowId> step_1 --yes",
+        "imbrace workflow node delete <flowId> step_2 --yes --json",
+    ];
+    static args = {
+        flowId: Args.string({ description: "Workflow ID", required: true }),
+        nodeName: Args.string({ description: "Node name (e.g. 'step_1')", required: true }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: "y", description: "Skip confirmation" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowNodeDelete);
+        if (!flags.yes && !flags.json) {
+            const ok = await confirm({ message: `Delete node "${args.nodeName}" from flow ${args.flowId}?`, default: false });
+            if (!ok) {
+                this.log("Cancelled.");
+                return;
+            }
+        }
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/nodes/${args.nodeName}`, { method: "DELETE" });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${res.message}\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/node/list.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowNodeList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        flowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/node/list.js

@@ -0,0 +1,40 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowNodeList extends BaseCommand {
+    static description = "List nodes (trigger + actions) of a workflow";
+    static examples = [
+        "imbrace workflow node list <flowId>",
+        "imbrace workflow node list <flowId> --json",
+    ];
+    static args = {
+        flowId: Args.string({ description: "Workflow ID", required: true }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowNodeList);
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/nodes`);
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n  Found ${res.count} node(s):\n`);
+            this.log("  NAME       TYPE             PIECE                                  ACTION/TRIGGER");
+            this.log("  ─────────────────────────────────────────────────────────────────────────────────");
+            for (const n of res.data || []) {
+                const name = (n.name || "").padEnd(10);
+                const type = (n.type || "").padEnd(16);
+                const piece = (n.pieceName || "-").padEnd(38);
+                const at = n.actionName || n.triggerName || "-";
+                this.log(`  ${name} ${type} ${piece} ${at}`);
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/node/update.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowNodeUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        flowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        nodeName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "display-name": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/node/update.js

@@ -0,0 +1,47 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowNodeUpdate extends BaseCommand {
+    static description = "Update a node's input or display name (preserves piece + action/trigger)";
+    static examples = [
+        'imbrace workflow node update <flowId> step_1 --input \'{"prompt":"new prompt"}\' --json',
+        'imbrace workflow node update <flowId> step_1 --display-name "Ask AI" --json',
+    ];
+    static args = {
+        flowId: Args.string({ description: "Workflow ID", required: true }),
+        nodeName: Args.string({ description: "Node name (e.g. 'trigger', 'step_1')", required: true }),
+    };
+    static flags = {
+        input: Flags.string({ description: "New JSON input (replaces current)" }),
+        "display-name": Flags.string({ description: "New display name" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowNodeUpdate);
+        if (!flags.input && !flags["display-name"]) {
+            this.error("Provide at least --input or --display-name to update");
+        }
+        const body = {};
+        if (flags.input) {
+            try {
+                body.input = JSON.parse(flags.input);
+            }
+            catch (e) {
+                this.error(`--input is not valid JSON: ${e.message}`);
+            }
+        }
+        if (flags["display-name"])
+            body.displayName = flags["display-name"];
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/nodes/${args.nodeName}`, { method: "PUT", body });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${res.message}\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/piece/detail.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowPieceDetail extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        piece: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        only: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/piece/detail.js

@@ -0,0 +1,60 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowPieceDetail extends BaseCommand {
+    static description = "Get full piece schema (actions + triggers + input fields)";
+    static examples = [
+        "imbrace workflow piece detail slack",
+        'imbrace workflow piece detail "@activepieces/piece-slack" --json',
+        "imbrace workflow piece detail slack --only actions",
+    ];
+    static args = {
+        piece: Args.string({ description: "Piece name (e.g. 'slack' or '@activepieces/piece-slack')" }),
+    };
+    static flags = {
+        only: Flags.string({ description: "Show only one section: actions | triggers", options: ["actions", "triggers"] }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowPieceDetail);
+        const piece = args.piece ?? (flags.json ? this.error("piece is required") : await input({ message: "Piece name (e.g. slack):" }));
+        try {
+            const res = await apiRequest(`/workflow/piece/detail?name=${encodeURIComponent(piece)}`);
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const d = res.data || {};
+            this.log(`\n  ${d.displayName} (${d.name})`);
+            this.log(`  ${d.description || ""}`);
+            this.log(`  Version: ${d.version}    Categories: ${(d.categories || []).join(", ")}`);
+            const actions = d.actions || {};
+            const triggers = d.triggers || {};
+            if (flags.only !== "triggers") {
+                this.log(`\n  ACTIONS (${Object.keys(actions).length}):`);
+                for (const [name, a] of Object.entries(actions)) {
+                    this.log(`    ${name}`);
+                    this.log(`      ${a.displayName} — ${(a.description || "").slice(0, 80)}`);
+                    const props = Object.keys(a.props || {}).slice(0, 6).join(", ");
+                    if (props)
+                        this.log(`      props: ${props}${Object.keys(a.props).length > 6 ? ", ..." : ""}`);
+                }
+            }
+            if (flags.only !== "actions") {
+                this.log(`\n  TRIGGERS (${Object.keys(triggers).length}):`);
+                for (const [name, t] of Object.entries(triggers)) {
+                    this.log(`    ${name}`);
+                    this.log(`      ${t.displayName} — ${(t.description || "").slice(0, 80)}`);
+                    const props = Object.keys(t.props || {}).slice(0, 6).join(", ");
+                    if (props)
+                        this.log(`      props: ${props}${Object.keys(t.props).length > 6 ? ", ..." : ""}`);
+                }
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/piece/list.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowPieceList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        search: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/piece/list.js

@@ -0,0 +1,40 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowPieceList extends BaseCommand {
+    static description = "List available integrations (pieces) for use in workflow nodes";
+    static examples = [
+        "imbrace workflow piece list",
+        'imbrace workflow piece list --search slack',
+        "imbrace workflow piece list --json",
+    ];
+    static flags = {
+        search: Flags.string({ char: "s", description: "Filter by name/displayName/description (case-insensitive)" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowPieceList);
+        const qs = flags.search ? `?search=${encodeURIComponent(flags.search)}` : "";
+        try {
+            const res = await apiRequest(`/workflow/piece/list${qs}`);
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n  Found ${res.count} piece(s)${flags.search ? ` matching "${flags.search}"` : ""}:\n`);
+            this.log("  NAME                                          DISPLAY                          A  T");
+            this.log("  ──────────────────────────────────────────────────────────────────────────────────");
+            for (const p of res.data || []) {
+                const name = (p.name || "").padEnd(45);
+                const display = (p.displayName || "").padEnd(32);
+                const a = String(p.actions ?? 0).padStart(2);
+                const t = String(p.triggers ?? 0).padStart(2);
+                this.log(`  ${name} ${display} ${a} ${t}`);
+            }
+            this.log(`\n  A=actions, T=triggers. Run 'imbrace workflow piece detail --name <pieceName>' for full schema.\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/run-detail.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WorkflowRunDetail extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        runId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workflow/run-detail.js

@@ -0,0 +1,50 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { apiRequest } from "../../http.js";
+export default class WorkflowRunDetail extends BaseCommand {
+    static description = "Get details of a single workflow run (status, failed step, timing)";
+    static examples = [
+        "imbrace workflow run-detail <runId>",
+        "imbrace workflow run-detail <runId> --json",
+    ];
+    static args = {
+        runId: Args.string({ description: "Run ID" }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowRunDetail);
+        const runId = args.runId ?? (flags.json ? this.error("Run ID is required") : await input({ message: "Run ID:" }));
+        try {
+            const res = await apiRequest(`/workflow/runs/${runId}`);
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const r = res.data || {};
+            const dur = r.startTime && r.finishTime
+                ? `${((new Date(r.finishTime).getTime() - new Date(r.startTime).getTime()) / 1000).toFixed(2)}s`
+                : "—";
+            this.log(`\n  Run ID:       ${r.id || ""}`);
+            this.log(`  Flow ID:      ${r.flowId || ""}`);
+            this.log(`  Flow name:    ${r.flowVersion?.displayName || ""}`);
+            this.log(`  Status:       ${r.status || ""}`);
+            this.log(`  Environment:  ${r.environment || ""}`);
+            this.log(`  Started:      ${r.startTime || ""}`);
+            this.log(`  Finished:     ${r.finishTime || ""}`);
+            this.log(`  Duration:     ${dur}`);
+            if (r.failedStep && Object.keys(r.failedStep).length > 0) {
+                this.log(`  Failed step:  ${JSON.stringify(r.failedStep)}`);
+            }
+            if (r.logsFileId) {
+                this.log(`  Logs file ID: ${r.logsFileId}`);
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/runs.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WorkflowRuns extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}