@imbrace/cli 0.1.0 → 0.3.0

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

@@ -0,0 +1,30 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowFolderUpdate extends BaseCommand {
+    static description = "Rename a folder";
+    static examples = [
+        'imbrace workflow folder update <folderId> --name "New Name" --json',
+    ];
+    static args = {
+        folderId: Args.string({ description: "Folder ID", required: true }),
+    };
+    static flags = {
+        name: Flags.string({ char: "n", description: "New folder name", required: true }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowFolderUpdate);
+        try {
+            const res = await apiRequest(`/workflow/folder/${args.folderId}`, { method: "PUT", body: { name: flags.name } });
+            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/list.d.ts

@@ -3,6 +3,7 @@ export default class WorkflowList extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        "folder-id": 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/list.js

@@ -6,14 +6,20 @@ export default class WorkflowList extends BaseCommand {
     static examples = [
         "imbrace workflow list",
         "imbrace workflow list --json",
+        "imbrace workflow list --folder-id <folderId>",
+        "imbrace workflow list --folder-id NULL  # only unfiled flows",
     ];
     static flags = {
+        "folder-id": Flags.string({
+            description: "Filter to flows in this folder. Use 'NULL' to show only unfiled flows. Use 'imbrace workflow folder list' to discover folder IDs.",
+        }),
         json: Flags.boolean({ description: "Output as JSON" }),
     };
     async run() {
         const { flags } = await this.parse(WorkflowList);
+        const qs = flags["folder-id"] ? `?folderId=${encodeURIComponent(flags["folder-id"])}` : "";
         try {
-            const res = await apiRequest("/workflow/list");
+            const res = await apiRequest(`/workflow/list${qs}`);
             if (flags.json) {
                 this.log(JSON.stringify(res, null, 2));
                 return;

package/dist/commands/workflow/mcp/create.d.ts

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

package/dist/commands/workflow/mcp/create.js

@@ -0,0 +1,44 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowMcpCreate extends BaseCommand {
+    static description = "Create a new MCP (Model Context Protocol) server. The token is shown once at creation — save it.";
+    static examples = [
+        'imbrace workflow mcp create --name "My MCP" --json',
+        'imbrace workflow mcp create --name "Claude MCP" --id-only',
+    ];
+    static flags = {
+        name: Flags.string({ char: "n", description: "MCP server name (required)" }),
+        "project-id": Flags.string({ description: "Project ID. Auto-discovered if omitted." }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+        "id-only": Flags.boolean({ description: "Print only the new MCP ID (pipe-friendly)" }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowMcpCreate);
+        const nonInteractive = flags.json || flags["id-only"];
+        const name = flags.name ?? (nonInteractive ? this.error("--name is required with --json or --id-only") : await input({ message: "MCP name:" }));
+        const body = { name };
+        if (flags["project-id"])
+            body.projectId = flags["project-id"];
+        try {
+            const res = await apiRequest("/workflow/mcp/create", { method: "POST", body });
+            if (flags["id-only"]) {
+                this.log(res.data?.id ?? "");
+                return;
+            }
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const m = res.data || {};
+            this.log(`\n✅ ${res.message}`);
+            this.log(`   ID:    ${m.id}`);
+            this.log(`   Token: ${m.token}`);
+            this.log(`\n  ⚠️  Save the token now — it WON'T be shown again. Use 'mcp rotate-token <id>' to issue a new one.\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowMcpDelete extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        mcpId: 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/mcp/delete.js

@@ -0,0 +1,39 @@
+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 WorkflowMcpDelete extends BaseCommand {
+    static description = "Delete an MCP server. Any client using its token will lose access.";
+    static examples = [
+        "imbrace workflow mcp delete <mcpId> --yes",
+        "imbrace workflow mcp delete <mcpId> --yes --json",
+    ];
+    static args = {
+        mcpId: Args.string({ description: "MCP server ID", 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(WorkflowMcpDelete);
+        if (!flags.yes && !flags.json) {
+            const ok = await confirm({ message: `Delete MCP server ${args.mcpId}?`, default: false });
+            if (!ok) {
+                this.log("Cancelled.");
+                return;
+            }
+        }
+        try {
+            const res = await apiRequest(`/workflow/mcp/${args.mcpId}`, { 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/mcp/get.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowMcpGet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        mcpId: 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/mcp/get.js

@@ -0,0 +1,40 @@
+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 WorkflowMcpGet extends BaseCommand {
+    static description = "Get details of a single MCP server (token is NOT shown — use rotate-token to get a new one)";
+    static examples = [
+        "imbrace workflow mcp get <mcpId>",
+        "imbrace workflow mcp get <mcpId> --json",
+    ];
+    static args = {
+        mcpId: Args.string({ description: "MCP server ID" }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowMcpGet);
+        const mcpId = args.mcpId ?? (flags.json ? this.error("MCP ID is required") : await input({ message: "MCP server ID:" }));
+        try {
+            const res = await apiRequest(`/workflow/mcp/${mcpId}`);
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const m = res.data || {};
+            this.log(`\n  ID:           ${m.id || ""}`);
+            this.log(`  Name:         ${m.name || ""}`);
+            this.log(`  Project ID:   ${m.projectId || ""}`);
+            this.log(`  External ID:  ${m.externalId || ""}`);
+            this.log(`  Tools:        ${(m.tools || []).length}`);
+            this.log(`  Created:      ${m.created || ""}`);
+            this.log(`  Updated:      ${m.updated || ""}`);
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

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

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

package/dist/commands/workflow/mcp/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 WorkflowMcpList extends BaseCommand {
+    static description = "List MCP (Model Context Protocol) servers for the project";
+    static examples = [
+        "imbrace workflow mcp list",
+        "imbrace workflow mcp list --json",
+    ];
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowMcpList);
+        try {
+            const res = await apiRequest("/workflow/mcp/list");
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n  Found ${res.count} MCP server(s):\n`);
+            this.log("  ID                       NAME                       TOOLS");
+            this.log("  ──────────────────────────────────────────────────────────");
+            for (const m of res.data || []) {
+                const id = (m.id || "").padEnd(24);
+                const name = (m.name || "").padEnd(26);
+                const tools = (m.tools || []).length;
+                this.log(`  ${id} ${name} ${tools}`);
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/workflow/mcp/rotate-token.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../../base-command.js";
+export default class WorkflowMcpRotateToken extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        mcpId: 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/mcp/rotate-token.js

@@ -0,0 +1,46 @@
+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 WorkflowMcpRotateToken extends BaseCommand {
+    static description = "Rotate the access token of an MCP server. Old token stops working immediately.";
+    static examples = [
+        "imbrace workflow mcp rotate-token <mcpId> --yes",
+        "imbrace workflow mcp rotate-token <mcpId> --yes --json",
+    ];
+    static args = {
+        mcpId: Args.string({ description: "MCP server ID", 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(WorkflowMcpRotateToken);
+        if (!flags.yes && !flags.json) {
+            const ok = await confirm({
+                message: `Rotate token for MCP ${args.mcpId}? Old token stops working immediately.`,
+                default: false,
+            });
+            if (!ok) {
+                this.log("Cancelled.");
+                return;
+            }
+        }
+        try {
+            const res = await apiRequest(`/workflow/mcp/${args.mcpId}/rotate-token`, { method: "POST", body: {} });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const m = res.data || {};
+            this.log(`\n✅ ${res.message}`);
+            this.log(`   ID:        ${m.id}`);
+            this.log(`   New token: ${m.token}`);
+            this.log(`\n  ⚠️  Update any clients using the old token.\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

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

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

package/dist/commands/workflow/move.js

@@ -0,0 +1,35 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { apiRequest } from "../../http.js";
+export default class WorkflowMove extends BaseCommand {
+    static description = "Move a workflow into a folder (category). Pass --folder-id NULL to make it unfiled.";
+    static examples = [
+        "imbrace workflow move <flowId> --folder-id <folderId>",
+        "imbrace workflow move <flowId> --folder-id NULL  # remove from any folder",
+    ];
+    static args = {
+        id: Args.string({ description: "Workflow ID", required: true }),
+    };
+    static flags = {
+        "folder-id": Flags.string({
+            description: "Target folder ID. Use 'NULL' to unfile. Use 'imbrace workflow folder list' to discover folder IDs.",
+            required: true,
+        }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowMove);
+        const folderId = flags["folder-id"] === "NULL" ? null : flags["folder-id"];
+        try {
+            const res = await apiRequest(`/workflow/${encodeURIComponent(args.id)}/move`, { method: "POST", body: { folderId } });
+            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/add-raw.d.ts

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

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

@@ -0,0 +1,70 @@
+import { Args, Flags } from "@oclif/core";
+import { readFileSync } from "node:fs";
+import { BaseCommand } from "../../../base-command.js";
+import { apiRequest } from "../../../http.js";
+export default class WorkflowNodeAddRaw extends BaseCommand {
+    static description = [
+        "Add or update a node using a raw Activepieces flow-operation payload.",
+        "Use this for advanced node types (BRANCH, ROUTER, LOOP_ON_ITEMS, CODE)",
+        "that 'node add' doesn't expose. Caller is responsible for the full",
+        "payload shape — no validation, no auto-defaults.",
+    ].join(" ");
+    static examples = [
+        "imbrace workflow node add-raw <flowId> --op-file ./branch.json --json",
+        "imbrace workflow node add-raw <flowId> --op '{\"type\":\"ADD_ACTION\",\"request\":{...}}' --json",
+        "echo '{\"type\":\"ADD_ACTION\",...}' | imbrace workflow node add-raw <flowId> --stdin --json",
+    ];
+    static args = {
+        flowId: Args.string({ description: "Workflow ID", required: true }),
+    };
+    static flags = {
+        "op-file": Flags.string({ description: "Path to JSON file containing { type, request }" }),
+        op: Flags.string({ description: "Inline JSON string of { type, request }" }),
+        stdin: Flags.boolean({ description: "Read operation JSON from stdin" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowNodeAddRaw);
+        const sources = [flags["op-file"], flags.op, flags.stdin].filter(Boolean).length;
+        if (sources === 0)
+            this.error("Provide one of --op-file, --op, or --stdin");
+        if (sources > 1)
+            this.error("Use only one of --op-file, --op, --stdin");
+        let raw;
+        if (flags["op-file"]) {
+            try {
+                raw = readFileSync(flags["op-file"], "utf8");
+            }
+            catch (e) {
+                this.error(`Cannot read --op-file: ${e.message}`);
+            }
+        }
+        else if (flags.op) {
+            raw = flags.op;
+        }
+        else {
+            raw = readFileSync(0, "utf8");
+        }
+        let body;
+        try {
+            body = JSON.parse(raw);
+        }
+        catch (e) {
+            this.error(`Invalid JSON: ${e.message}`);
+        }
+        if (!body.type || !body.request) {
+            this.error("Operation JSON must have { type, request } — e.g. { type: \"ADD_ACTION\", request: { parentStep, action } }");
+        }
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/nodes/raw`, { method: "POST", 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/publish.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WorkflowPublish 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/publish.js

@@ -0,0 +1,30 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { apiRequest } from "../../http.js";
+export default class WorkflowPublish extends BaseCommand {
+    static description = "Lock the current draft and publish it as the production version. Required before 'workflow enable'.";
+    static examples = [
+        "imbrace workflow publish <flowId>",
+        "imbrace workflow publish <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(WorkflowPublish);
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/publish`, { method: "POST", body: {} });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${res.message}\n  Run 'imbrace workflow enable ${args.flowId}' to start auto-triggering.\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

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

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

package/dist/commands/workflow/run.js

@@ -0,0 +1,50 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { apiRequest } from "../../http.js";
+export default class WorkflowRun extends BaseCommand {
+    static description = "Manually trigger a workflow with a payload. Use --sync to wait for completion.";
+    static examples = [
+        'imbrace workflow run <flowId> --payload \'{"text":"hello"}\' --json',
+        'imbrace workflow run <flowId> --payload \'{"text":"hello"}\' --sync --json',
+        'imbrace workflow run <flowId>  # no payload (empty {})',
+    ];
+    static args = {
+        flowId: Args.string({ description: "Workflow ID", required: true }),
+    };
+    static flags = {
+        payload: Flags.string({ description: "JSON payload (becomes trigger.body in flow). Default: {}" }),
+        sync: Flags.boolean({ description: "Wait for flow to finish (timeout ~60s). Without it, fire-and-forget." }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowRun);
+        let payload = {};
+        if (flags.payload) {
+            try {
+                payload = JSON.parse(flags.payload);
+            }
+            catch (e) {
+                this.error(`--payload is not valid JSON: ${e.message}`);
+            }
+        }
+        const qs = flags.sync ? "?sync=true" : "";
+        try {
+            const res = await apiRequest(`/workflow/${args.flowId}/run${qs}`, { method: "POST", body: { payload } });
+            if (flags.json) {
+                this.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${res.message}`);
+            if (flags.sync && res.data) {
+                this.log(`\n  Result:\n${JSON.stringify(res.data, null, 2).split("\n").map(l => "    " + l).join("\n")}`);
+            }
+            else if (!flags.sync) {
+                this.log(`\n  (async — use 'imbrace workflow runs' to check execution status)`);
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}