@cargo-ai/cli 1.0.19 → 1.0.20

package/README.md

@@ -98,25 +98,55 @@ cargo-ai orchestration workflow --help
 
 ### Domains and example commands
 
-| Domain                   | Description                                                | Example commands                                                                                                              |
-| ------------------------ | ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| **init**                 | Workspace initialisation (user, workspace, datasets, etc.) | `cargo-ai init`                                                                                                               |
-| **orchestration**        | Workflows, plays, runs, batches, tools, templates          | `cargo-ai orchestration workflow list`, `cargo-ai orchestration run list --workflow-uuid <uuid>`                              |
-| **workspaceManagement**  | Workspaces, users, tokens, roles, folders                  | `cargo-ai workspaceManagement workspaces list`, `cargo-ai workspaceManagement token list`                                     |
-| **storage**              | Datasets, models, relationships, runs, records             | `cargo-ai storage dataset list`, `cargo-ai storage model list`                                                                |
-| **connection**           | Connectors and integrations                                | `cargo-ai connection connector list`, `cargo-ai connection integration list`                                                  |
-| **billing**              | Usage and subscription                                     | `cargo-ai billing subscription get`, `cargo-ai billing usage get-metrics --payload '{"from":"2025-01-01","to":"2025-01-31"}'` |
-| **segmentation**         | Segments and changes                                       | `cargo-ai segmentation segment list`, `cargo-ai segmentation change list --payload '{}'`                                      |
-| **revenue-organization** | Allocations, capacities, members, territories              | `cargo-ai revenue-organization member list`, `cargo-ai revenue-organization territory list`                                   |
-| **expression**           | Recipes and expression evaluation                          | `cargo-ai expression recipe list`, `cargo-ai expression eval evaluate --payload '{}'`                                         |
-| **system-of-record**     | System of record, client, logs                             | `cargo-ai system-of-record sor list`, `cargo-ai system-of-record log list --payload '{}'`                                     |
-| **user-management**      | Current user (no workspace context)                        | `cargo-ai user-management user get-current`                                                                                   |
-| **ai**                   | AI templates, agents, releases, chats, MCP, files          | `cargo-ai ai template list`, `cargo-ai ai agent list`, `cargo-ai ai file list`                                                |
-| **context**              | Context repository, runtime sandbox, and knowledge graph   | `cargo-ai context repository get`, `cargo-ai context runtime browse --path <path>`, `cargo-ai context graph get`              |
-| **hosting**              | Cargo Hosting apps (Vite SPAs), workers, and deployments   | `cargo-ai hosting app list`, `cargo-ai hosting worker list`, `cargo-ai hosting deployment list --payload '{}'`                |
+| Domain                   | Description                                                   | Example commands                                                                                                              |
+| ------------------------ | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| **init**                 | Workspace initialisation (user, workspace, datasets, etc.)    | `cargo-ai init`                                                                                                               |
+| **orchestration**        | Workflows, plays, runs, batches, tools, templates             | `cargo-ai orchestration workflow list`, `cargo-ai orchestration run list --workflow-uuid <uuid>`                              |
+| **workspaceManagement**  | Workspaces, users, tokens, roles, folders                     | `cargo-ai workspaceManagement workspaces list`, `cargo-ai workspaceManagement token list`                                     |
+| **storage**              | Datasets, models, relationships, runs, records                | `cargo-ai storage dataset list`, `cargo-ai storage model list`                                                                |
+| **connection**           | Connectors and integrations                                   | `cargo-ai connection connector list`, `cargo-ai connection integration list`                                                  |
+| **billing**              | Usage and subscription                                        | `cargo-ai billing subscription get`, `cargo-ai billing usage get-metrics --payload '{"from":"2025-01-01","to":"2025-01-31"}'` |
+| **segmentation**         | Segments and changes                                          | `cargo-ai segmentation segment list`, `cargo-ai segmentation change list --payload '{}'`                                      |
+| **revenue-organization** | Allocations, capacities, members, territories                 | `cargo-ai revenue-organization member list`, `cargo-ai revenue-organization territory list`                                   |
+| **expression**           | Recipes and expression evaluation                             | `cargo-ai expression recipe list`, `cargo-ai expression eval evaluate --payload '{}'`                                         |
+| **system-of-record**     | System of record, client, logs                                | `cargo-ai system-of-record sor list`, `cargo-ai system-of-record log list --payload '{}'`                                     |
+| **user-management**      | Current user (no workspace context)                           | `cargo-ai user-management user get-current`                                                                                   |
+| **ai**                   | AI templates, agents, releases, chats, MCP, files             | `cargo-ai ai template list`, `cargo-ai ai agent list`, `cargo-ai ai file list`                                                |
+| **context**              | Context repository, runtime sandbox, and knowledge graph      | `cargo-ai context repository get`, `cargo-ai context runtime browse --path <path>`, `cargo-ai context graph get`              |
+| **hosting**              | Cargo Hosting apps (Vite SPAs), workers, and deployments      | `cargo-ai hosting app list`, `cargo-ai hosting worker list`, `cargo-ai hosting deployment list --payload '{}'`                |
+| **workflow**             | Workflow SDK developer tools: per-workspace type sync/codegen | `cargo-ai workflow sync` (SDK deploy lives at `cargo-ai orchestration release deploy-draft --file <path>`)                    |
 
 Commands that accept complex payloads use a `--payload <json>` option (e.g. `cargo-ai orchestration play create --payload '{"name":"My Play",...}'`). Use `--help` on any subcommand for options.
 
+### `orchestration release deploy-draft`
+
+Deploy a draft release of an **existing** workflow. Two input modes share the same command:
+
+```bash
+# Compile a Workflow SDK module and deploy it
+cargo-ai orchestration release deploy-draft --file ./my-workflow.ts
+
+# Preview the compiled nodes + form fields without deploying
+cargo-ai orchestration release deploy-draft --file ./my-workflow.ts --dry-run
+
+# Pin an explicit version + description
+cargo-ai orchestration release deploy-draft --file ./my-workflow.ts --workflow-uuid <uuid> --version 2.0.0 --description "New enrichment path"
+
+# Power-user path: deploy raw wire-format JSON
+cargo-ai orchestration release deploy-draft --workflow-uuid <uuid> --nodes '[…]' --form-fields '[…]'
+```
+
+`--file <path>` loads a [`@cargo-ai/workflow-sdk`](../workflow-sdk/README.md) module (its `export default defineWorkflow(...)`) and sources `nodes` / `formFields` / `description` from the compiled output. With `--file`:
+
+- `--workflow-uuid` is optional — when omitted, the command best-effort matches the compiled `slug` against existing workflows' `template.slug` and errors if the match is missing or ambiguous.
+- `--version` defaults to the next minor bump over the latest existing release (or `1.0.0` for the first).
+- `--description` defaults to the compiled workflow's description.
+- `--nodes` / `--form-fields` are rejected (they're sourced from the module).
+
+Without `--file`, `--workflow-uuid`, `--nodes`, and `--form-fields` are all required (raw JSON path). Constraint either way: there is **no** workflow-create endpoint, so the target workflow must already exist.
+
+Other release verbs (`list`, `get <uuid>`, `get-deployed`, `get-draft`, `update-draft`) live under the same group — see `cargo-ai orchestration release --help`.
+
 ## Agent Skills
 
 [Cargo Skills](https://github.com/getcargohq/cargo-skills) teaches AI coding agents (Claude Code, Cursor, Windsurf, GitHub Copilot, etc.) how to use the Cargo CLI. Install the skill to let your agent build, run, and manage revenue automation workflows programmatically:

package/build/commands/orchestration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAgBxC,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAmBN"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAexC,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAkBN"}

package/build/commands/orchestration/index.js

@@ -1,6 +1,5 @@
 import { registerActionCommands } from "./action.js";
 import { registerBatchCommands } from "./batch.js";
-import { registerDraftReleaseCommands } from "./draftRelease.js";
 import { registerNodeCommands } from "./node.js";
 import { registerPlayCommands } from "./play.js";
 import { registerQueryCommands } from "./query.js";
@@ -24,7 +23,6 @@ export function registerOrchestrationCommands(parent, getApi) {
     registerSpanCommands(orchestration, getApi);
     registerTraceCommands(orchestration, getApi);
     registerReleaseCommands(orchestration, getApi);
-    registerDraftReleaseCommands(orchestration, getApi);
     registerToolCommands(orchestration, getApi);
     registerRecordCommands(orchestration, getApi);
     registerTemplateCommands(orchestration, getApi);

package/build/commands/orchestration/release.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/release.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CA8DN"}
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/release.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAyCxC,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAkLN"}

package/build/commands/orchestration/release.js

@@ -1,8 +1,11 @@
-import { handleApiCall, outputJson } from "../runHandler.js";
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ExitCodes, failWith, handleApiCall, info, outputJson, parseJson, success, } from "../runHandler.js";
 export function registerReleaseCommands(parent, getApi) {
     const release = parent
         .command("release")
-        .description("Manage workflow releases (list, get, get-deployed)");
+        .description("Manage workflow releases (list, get, get-deployed, get-draft, update-draft, deploy-draft)");
     release
         .command("list")
         .description("List releases")
@@ -37,4 +40,255 @@ export function registerReleaseCommands(parent, getApi) {
         }));
         outputJson(result);
     });
+    release
+        .command("get-draft")
+        .description("Get the draft release for a workflow")
+        .requiredOption("--workflow-uuid <uuid>", "Workflow UUID")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.orchestration.draftRelease.get({
+            workflowUuid: opts.workflowUuid,
+        }));
+        outputJson(result);
+    });
+    release
+        .command("update-draft")
+        .description("Update the draft release of a workflow")
+        .requiredOption("--workflow-uuid <uuid>", "Workflow UUID")
+        .option("--parent-uuid <uuid>", "Parent release UUID")
+        .option("--nodes <json>", "Nodes (JSON array of node definitions)")
+        .option("--test-records <json>", "Test records (JSON array)")
+        .option("--form-fields <json>", "Form fields (JSON array, or 'null')")
+        .option("--options <json>", "Options (JSON object)")
+        .action(async (opts) => {
+        const api = getApi();
+        const result = await handleApiCall(() => api.orchestration.draftRelease.update({
+            workflowUuid: opts.workflowUuid,
+            parentUuid: opts.parentUuid,
+            nodes: opts.nodes !== undefined
+                ? parseJson(opts.nodes, "--nodes")
+                : undefined,
+            testRecords: opts.testRecords !== undefined
+                ? parseJson(opts.testRecords, "--test-records")
+                : undefined,
+            formFields: opts.formFields === "null"
+                ? null
+                : opts.formFields !== undefined
+                    ? parseJson(opts.formFields, "--form-fields")
+                    : undefined,
+            options: opts.options !== undefined
+                ? parseJson(opts.options, "--options")
+                : undefined,
+        }));
+        outputJson(result);
+    });
+    release
+        .command("deploy-draft")
+        .description("Deploy a draft release. Pass --file to compile a Workflow SDK module, or --nodes + --form-fields to deploy raw wire-format JSON.")
+        .option("--file <path>", "Path to a Workflow SDK module (its default export must be the compiled workflow returned by defineWorkflow()). When set, --nodes / --form-fields are sourced from the compiled output.")
+        .option("--workflow-uuid <uuid>", "Target workflow UUID. Required without --file; with --file, defaults to the existing workflow whose template.slug matches the compiled slug.")
+        .option("--version <version>", "Release version (e.g. '1.2.0'). With --file, defaults to the next minor bump over the latest existing release; otherwise required by the engine.")
+        .option("--nodes <json>", "Nodes (JSON array of node definitions). Required without --file; rejected with --file.")
+        .option("--form-fields <json>", "Form fields (JSON array, or 'null'). Required without --file; rejected with --file.")
+        .option("--description <text>", "Release description (with --file, defaults to the compiled workflow's description).")
+        .option("--options <json>", "Options (JSON object)")
+        .option("--dry-run", "With --file: compile and print the nodes + form fields without deploying. Ignored without --file.")
+        .action(async (opts) => {
+        if (opts.file !== undefined) {
+            await runFileDeploy(getApi, opts);
+            return;
+        }
+        await runJsonDeploy(getApi, opts);
+    });
+}
+// ---------- raw-JSON path (legacy `draft-release deploy`) ----------
+async function runJsonDeploy(getApi, opts) {
+    if (opts.workflowUuid === undefined) {
+        failWith("--workflow-uuid is required when --file is not set", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    if (opts.nodes === undefined) {
+        failWith("--nodes is required when --file is not set", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    if (opts.formFields === undefined) {
+        failWith("--form-fields is required when --file is not set", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    // Pull required values into locals so the narrowing survives the closure
+    // we hand to `handleApiCall` below.
+    const workflowUuid = opts.workflowUuid;
+    const nodesJson = opts.nodes;
+    const formFieldsJson = opts.formFields;
+    const api = getApi();
+    const result = await handleApiCall(() => api.orchestration.draftRelease.deploy({
+        workflowUuid,
+        version: opts.version,
+        nodes: parseJson(nodesJson, "--nodes"),
+        formFields: formFieldsJson === "null"
+            ? null
+            : parseJson(formFieldsJson, "--form-fields"),
+        description: opts.description,
+        options: opts.options !== undefined
+            ? parseJson(opts.options, "--options")
+            : undefined,
+    }));
+    outputJson(result);
+}
+// ---------- SDK-file path (replaces `workflow deploy <file>`) ----------
+async function runFileDeploy(getApi, opts) {
+    if (opts.file === undefined) {
+        failWith("--file is required for SDK deploy", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    if (opts.nodes !== undefined) {
+        failWith("--nodes is not allowed with --file (sourced from the module)", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    if (opts.formFields !== undefined) {
+        failWith("--form-fields is not allowed with --file (sourced from the module)", { code: ExitCodes.InvalidUsage });
+    }
+    const compiled = await loadCompiledWorkflow(opts.file);
+    if (opts.dryRun === true) {
+        outputJson({
+            slug: compiled.slug,
+            description: compiled.description,
+            nodes: compiled.nodes,
+            formFields: compiled.formFields,
+        });
+        return;
+    }
+    const api = getApi();
+    const workflowUuid = await resolveWorkflowUuid(api, compiled, opts.workflowUuid);
+    const version = opts.version !== undefined
+        ? opts.version
+        : await computeNextVersion(api, workflowUuid);
+    const description = opts.description !== undefined ? opts.description : compiled.description;
+    info(`Deploying "${compiled.slug}" → workflow ${workflowUuid} as v${version} (${String(compiled.nodes.length)} node(s))…`);
+    const payload = {
+        workflowUuid,
+        version,
+        nodes: compiled.nodes,
+        formFields: compiled.formFields,
+        description,
+        options: opts.options !== undefined
+            ? parseJson(opts.options, "--options")
+            : undefined,
+    };
+    const result = await handleApiCall(() => api.orchestration.draftRelease.deploy(payload));
+    success(`Deployed v${version}.`);
+    outputJson(result);
+}
+// Load a workflow module via the tsx ESM loader so `.ts` sources (and their
+// imports of `@cargo-ai/workflow-sdk` / `zod`) are transpiled on the fly,
+// returning its default export validated as a compiled workflow.
+async function loadCompiledWorkflow(file) {
+    const absPath = isAbsolute(file) ? file : resolve(process.cwd(), file);
+    if (!existsSync(absPath)) {
+        failWith(`Workflow file not found: ${absPath}`, {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    let mod;
+    try {
+        const { tsImport } = await import("tsx/esm/api");
+        mod = (await tsImport(pathToFileURL(absPath).href, import.meta.url));
+    }
+    catch (error) {
+        failWith(`Failed to load workflow module: ${error instanceof Error ? error.message : String(error)}`, { code: ExitCodes.GenericError });
+    }
+    const candidate = resolveDefaultExport(mod);
+    if (!isCompiledWorkflow(candidate)) {
+        failWith("Workflow module must `export default` a compiled workflow (the value returned by defineWorkflow()).", { code: ExitCodes.InvalidUsage });
+    }
+    return candidate;
+}
+// Peel the extra interop layer tsx adds when a TS source is transpiled to
+// CJS: the ESM namespace's `default` is then the CJS `module.exports`
+// (`{ __esModule: true, default: … }`), so the real value lives one level
+// deeper. True-ESM modules expose it directly.
+function resolveDefaultExport(mod) {
+    const top = mod.default;
+    if (top !== null && typeof top === "object") {
+        const inner = top;
+        if (inner["__esModule"] === true && "default" in inner) {
+            return inner["default"];
+        }
+    }
+    return top;
+}
+function isCompiledWorkflow(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const v = value;
+    return (typeof v["slug"] === "string" &&
+        Array.isArray(v["nodes"]) &&
+        Array.isArray(v["formFields"]));
+}
+// Resolve the target workflow UUID. The platform `Workflow` has no free-form
+// slug field — the closest stable identifier is `template.slug` — and there
+// is no `workflow.create` endpoint, so an explicit `--workflow-uuid` always
+// wins and slug matching is a best-effort convenience over existing
+// workflows only.
+async function resolveWorkflowUuid(api, compiled, explicitUuid) {
+    if (explicitUuid !== undefined)
+        return explicitUuid;
+    const { workflows } = await handleApiCall(() => api.orchestration.workflow.all());
+    const matches = workflows.filter((w) => {
+        const template = w.template;
+        return (template !== null &&
+            template !== undefined &&
+            template.slug === compiled.slug);
+    });
+    if (matches.length === 1) {
+        const match = matches[0];
+        if (match !== undefined) {
+            info(`Matched workflow ${match.uuid} by slug "${compiled.slug}".`);
+            return match.uuid;
+        }
+    }
+    if (matches.length > 1) {
+        failWith(`Multiple workflows match slug "${compiled.slug}". Pass --workflow-uuid to disambiguate.`, {
+            code: ExitCodes.InvalidUsage,
+            extra: { candidates: matches.map((w) => w.uuid) },
+        });
+    }
+    failWith(`No workflow matched slug "${compiled.slug}". Create the workflow in the app first (there is no create endpoint), then deploy with --workflow-uuid <uuid>.`, { code: ExitCodes.NotFound });
+}
+// Derive the next release version by bumping the minor of the highest
+// existing semver, or `1.0.0` when there are no prior releases.
+async function computeNextVersion(api, workflowUuid) {
+    const { releases } = await handleApiCall(() => api.orchestration.release.list({ workflowUuid }));
+    let best;
+    for (const release of releases) {
+        const parsed = parseSemver(release.version);
+        if (parsed === undefined)
+            continue;
+        if (best === undefined || compareSemver(parsed, best) > 0) {
+            best = parsed;
+        }
+    }
+    if (best === undefined)
+        return "1.0.0";
+    return `${String(best[0])}.${String(best[1] + 1)}.0`;
+}
+function parseSemver(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value.trim());
+    if (match === null)
+        return undefined;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemver(a, b) {
+    if (a[0] !== b[0])
+        return a[0] - b[0];
+    if (a[1] !== b[1])
+        return a[1] - b[1];
+    return a[2] - b[2];
 }

package/build/commands/workflow/index.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerWorkflowCommands(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=index.d.ts.map

package/build/commands/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAMxC,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CAMN"}

package/build/commands/workflow/index.js

@@ -0,0 +1,10 @@
+import { registerSyncCommand } from "./sync.js";
+// SDK deploy lives under `cargo-ai orchestration release deploy-draft --file
+// <path>` (alongside the raw-JSON deploy path), so this group only ships the
+// `sync` developer tool today.
+export function registerWorkflowCommands(parent, getApi) {
+    const workflow = parent
+        .command("workflow")
+        .description("Workflow SDK developer tools (type sync, codegen)");
+    registerSyncCommand(workflow, getApi);
+}

package/build/commands/workflow/inputTypes.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Fixed input shape of every agent node. Matches the SDK's `AgentInput`
+ * type and the engine's `AiUtils.agentConfig` schema.
+ */
+export declare const AGENT_INPUT_TYPE_SRC: string;
+/**
+ * Print an integration action's JSON Schema config as a TS input type.
+ * Returns `"Record<string, unknown>"` when the schema is missing or not an
+ * object schema we can render.
+ */
+export declare function printJsonSchemaInput(schema: unknown): string;
+/**
+ * Print a tool release's `formFields` as a TS input type. Returns
+ * `undefined` when the fields can't be interpreted (caller falls back to
+ * `Record<string, unknown>`).
+ */
+export declare function printFormFieldsInput(formFields: unknown): string | undefined;
+//# sourceMappingURL=inputTypes.d.ts.map

package/build/commands/workflow/inputTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputTypes.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/inputTypes.ts"],"names":[],"mappings":"AAgCA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAE+D,CAAC;AAEjG;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAM5D;AAgGD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU5E"}

package/build/commands/workflow/inputTypes.js

@@ -0,0 +1,175 @@
+// TypeScript input-type printers for `cargo-ai workflow sync` codegen.
+//
+// Three sources of truth, three printers:
+//   - Integration actions expose their config as JSON Schema on
+//     `connection.integration.list` (`action.config.schema`).
+//   - Workspace tools expose their input as `formFields` on the tool
+//     workflow's deployed release (`orchestration.release.getDeployed`).
+//   - Agent nodes accept a single global shape (`{ prompt, output? }`) —
+//     the engine validates every agent node against `AiUtils.agentConfig`.
+//
+// All printers run in "input mode": each top-level property is widened to
+// `Ref<T> | T` so callers can pass either a builder Ref or a literal.
+// Anything unrecognized falls back to `unknown` — codegen must never abort
+// on a schema edge case.
+//
+// Mirrors `packages/workflow-sdk/scripts/lib/jsonSchemaToTs.ts` (which is a
+// build-time-only script the CLI can't import).
+/**
+ * Fixed input shape of every agent node. Matches the SDK's `AgentInput`
+ * type and the engine's `AiUtils.agentConfig` schema.
+ */
+export const AGENT_INPUT_TYPE_SRC = `{ prompt: Ref<string> | string; ` +
+    `output?: { type: "default" | "text" | "jsonSchema"; jsonSchema?: Record<string, unknown> } }`;
+/**
+ * Print an integration action's JSON Schema config as a TS input type.
+ * Returns `"Record<string, unknown>"` when the schema is missing or not an
+ * object schema we can render.
+ */
+export function printJsonSchemaInput(schema) {
+    if (schema === null || typeof schema !== "object") {
+        return "Record<string, unknown>";
+    }
+    const printed = printSchema(schema, true);
+    return printed === "unknown" ? "Record<string, unknown>" : printed;
+}
+function printSchema(schema, topLevel) {
+    if (Array.isArray(schema.type)) {
+        return uniqueUnion(schema.type.map((t) => printPrimitive(t, schema, false)));
+    }
+    if (schema.enum !== undefined && schema.enum.length > 0) {
+        return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+    }
+    if (schema.const !== undefined) {
+        return JSON.stringify(schema.const);
+    }
+    if (schema.oneOf !== undefined && schema.oneOf.length > 0) {
+        return uniqueUnion(schema.oneOf.map((s) => printSchema(s, false)));
+    }
+    if (schema.anyOf !== undefined && schema.anyOf.length > 0) {
+        return uniqueUnion(schema.anyOf.map((s) => printSchema(s, false)));
+    }
+    if (schema.allOf !== undefined && schema.allOf.length > 0) {
+        // Conservative: render the head rather than a TS intersection.
+        return printSchema(schema.allOf[0], topLevel);
+    }
+    if (typeof schema.type !== "string")
+        return "unknown";
+    return printPrimitive(schema.type, schema, topLevel);
+}
+function printPrimitive(type, schema, topLevel) {
+    switch (type) {
+        case "string":
+            return "string";
+        case "number":
+        case "integer":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "null":
+            return "null";
+        case "array":
+            return printArray(schema);
+        case "object":
+            return printObject(schema, topLevel);
+        default:
+            return "unknown";
+    }
+}
+function printArray(schema) {
+    if (schema.items === undefined)
+        return "unknown[]";
+    if (Array.isArray(schema.items)) {
+        return `[${schema.items.map((s) => printSchema(s, false)).join(", ")}]`;
+    }
+    return `Array<${printSchema(schema.items, false)}>`;
+}
+function printObject(schema, topLevel) {
+    const props = schema.properties;
+    if (props === undefined) {
+        if (typeof schema.additionalProperties === "object" &&
+            schema.additionalProperties !== null) {
+            return `Record<string, ${printSchema(schema.additionalProperties, false)}>`;
+        }
+        return "Record<string, unknown>";
+    }
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const fields = [];
+    for (const [key, child] of Object.entries(props)) {
+        const inner = printSchema(child, false);
+        // Only top-level properties are Ref-widened; nested values are plain.
+        const value = topLevel ? `Ref<${inner}> | ${inner}` : inner;
+        const opt = required.has(key) ? "" : "?";
+        fields.push(`${tsKey(key)}${opt}: ${value}`);
+    }
+    if (fields.length === 0)
+        return "Record<string, never>";
+    return `{ ${fields.join("; ")} }`;
+}
+/**
+ * Print a tool release's `formFields` as a TS input type. Returns
+ * `undefined` when the fields can't be interpreted (caller falls back to
+ * `Record<string, unknown>`).
+ */
+export function printFormFieldsInput(formFields) {
+    if (!Array.isArray(formFields))
+        return undefined;
+    const fields = formFields.filter(isFormFieldLike);
+    if (fields.length === 0)
+        return "Record<string, never>";
+    const rendered = fields.map((f) => {
+        const inner = formFieldToTs(f);
+        const opt = f.isRequired === true ? "" : "?";
+        return `${tsKey(f.slug)}${opt}: Ref<${inner}> | ${inner}`;
+    });
+    return `{ ${rendered.join("; ")} }`;
+}
+function isFormFieldLike(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const v = value;
+    return typeof v["slug"] === "string" && typeof v["kind"] === "string";
+}
+function formFieldToTs(field) {
+    switch (field.kind) {
+        case "string":
+        case "date":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "enum": {
+            const values = Array.isArray(field.enum)
+                ? field.enum.filter((v) => typeof v === "string")
+                : [];
+            if (values.length === 0)
+                return "string";
+            return values.map((v) => JSON.stringify(v)).join(" | ");
+        }
+        case "array": {
+            const nested = Array.isArray(field.fields)
+                ? field.fields.filter(isFormFieldLike)
+                : [];
+            if (nested.length === 0)
+                return "unknown[]";
+            const inner = nested
+                .map((f) => {
+                const opt = f.isRequired === true ? "" : "?";
+                return `${tsKey(f.slug)}${opt}: ${formFieldToTs(f)}`;
+            })
+                .join("; ");
+            return `Array<{ ${inner} }>`;
+        }
+        case "any":
+        default:
+            return "unknown";
+    }
+}
+function uniqueUnion(parts) {
+    const dedup = Array.from(new Set(parts));
+    return dedup.length === 1 ? dedup[0] : dedup.join(" | ");
+}
+function tsKey(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}

package/build/commands/workflow/sync.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerSyncCommand(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=sync.d.ts.map

package/build/commands/workflow/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAgGxC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAsD5E"}

package/build/commands/workflow/sync.js

@@ -0,0 +1,454 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { handleApiCall, info, success } from "../runHandler.js";
+import { AGENT_INPUT_TYPE_SRC, printFormFieldsInput, printJsonSchemaInput, } from "./inputTypes.js";
+// Composite natives surfaced via dedicated SDK syntax / scope helpers —
+// excluded so we don't double-register them. Mirrors the codegen exclusion
+// list in `packages/workflow-sdk/scripts/generateNativeIntegration.ts`
+// (everything in the `logic` category gets dedicated syntax instead of
+// going through `native.<slug>`).
+const COMPOSITE_NATIVE = new Set([
+    "start",
+    "end",
+    "agent",
+    "balance",
+    "branch",
+    "delay",
+    "filter",
+    "group",
+    "humanReview",
+    "memory",
+    "split",
+    "switch",
+    "tool",
+    "variables",
+]);
+// Native actions the SDK already ships typed declarations + registrations
+// for (platform-level, identical in every workspace) — skipped so the
+// synced `.d.ts` doesn't redeclare `Native` properties with conflicting
+// (looser) types. Source of truth lives in
+// `packages/workflow-sdk/src/native/manifest.generated.ts`.
+const BUNDLED_NATIVE = new Set([
+    "note",
+    "python",
+    "scoring",
+    "script",
+]);
+export function registerSyncCommand(parent, getApi) {
+    parent
+        .command("sync")
+        .description("Generate per-workspace TypeScript types + eager registration for the Cargo Workflow SDK")
+        .option("--out <dir>", "Output directory for generated files (default: .cargo-ai)", ".cargo-ai")
+        .option("--cwd <dir>", "Working directory the --out path is resolved against (default: process.cwd())")
+        .action(async (opts) => {
+        const api = getApi();
+        const baseDir = opts.cwd !== undefined ? opts.cwd : process.cwd();
+        const outDir = resolve(baseDir, opts.out);
+        info(`Fetching workspace surface…`);
+        const payload = await fetchWorkspaceSurface(api);
+        mkdirSync(outDir, { recursive: true });
+        const typesPath = resolve(outDir, "cargo-types.d.ts");
+        writeFileSync(typesPath, renderTypes(payload));
+        success(`Wrote ${relativeToBase(baseDir, typesPath)}`);
+        const eagerPath = resolve(outDir, "cargo-register.ts");
+        writeFileSync(eagerPath, renderEagerRegistration(payload));
+        success(`Wrote ${relativeToBase(baseDir, eagerPath)}`);
+        info(``);
+        info([
+            `Next steps:`,
+            `  1. Add ${relativeToBase(baseDir, outDir)} to your tsconfig include`,
+            `     so the .d.ts is picked up.`,
+            `  2. Add \`import "./${relativeToBase(baseDir, eagerPath).replace(/\.ts$/, ".js")}";\``,
+            `     to your project's entry file (or before any defineWorkflow call)`,
+            `     so the workspace's integrations / tools / agents register at runtime.`,
+        ].join("\n"));
+        info(``);
+        info(`Synced ${String(payload.integrations.length)} integration(s), ${String(payload.tools.length)} tool(s), ${String(payload.agents.length)} agent(s), ${String(payload.native.length)} native action(s).`);
+    });
+}
+async function fetchWorkspaceSurface(api) {
+    const integrationsResult = await handleApiCall(() => api.connection.integration.list({}));
+    const nativeIntegrationResult = await handleApiCall(() => api.connection.nativeIntegration.get());
+    const orchestrationToolsResult = await handleApiCall(() => api.orchestration.tool.all());
+    const aiAgentsResult = await handleApiCall(() => api.ai.agent.all());
+    const integrations = collectIntegrations(integrationsResult.integrations);
+    const tools = collectTools(orchestrationToolsResult.tools);
+    await resolveToolInputTypes(api, tools);
+    const agents = collectAgents(aiAgentsResult);
+    const native = collectNative(nativeIntegrationResult.nativeIntegration.actions);
+    return { integrations, tools, agents, native };
+}
+function collectIntegrations(integrations) {
+    const out = [];
+    for (const integration of integrations) {
+        const actionEntries = Object.entries(integration.actions ?? {}).sort(([a], [b]) => a.localeCompare(b));
+        if (actionEntries.length === 0)
+            continue;
+        const actions = actionEntries.map(([slug, raw]) => {
+            const meta = raw;
+            return {
+                slug,
+                name: trimOrUndefined(meta.name),
+                description: trimOrUndefined(meta.description),
+                inputTypeSrc: printJsonSchemaInput(meta.config?.schema),
+            };
+        });
+        out.push({
+            slug: integration.slug,
+            name: trimOrUndefined(integration.name),
+            description: trimOrUndefined(integration.description),
+            actions,
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+function collectTools(workspaceTools) {
+    const out = [];
+    const used = new Set();
+    for (const t of workspaceTools) {
+        out.push({
+            slug: pickSlug(t.name, t.uuid, used),
+            name: t.name,
+            description: trimOrUndefined(t.description),
+            uuid: t.uuid,
+            workflowUuid: t.workflowUuid,
+            updatedAt: dateToIso(t.updatedAt),
+            inputTypeSrc: "Record<string, unknown>",
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+// The tools list endpoint doesn't carry input schemas — they live on each
+// tool workflow's deployed release as `formFields`. Resolve them with one
+// `release.getDeployed` call per tool (bounded concurrency). A tool without
+// a deployed release (or whose release fetch fails) keeps the
+// `Record<string, unknown>` fallback; sync must not abort over one tool.
+const TOOL_RELEASE_CONCURRENCY = 5;
+async function resolveToolInputTypes(api, tools) {
+    const queue = [...tools];
+    const workers = Array.from({ length: Math.min(TOOL_RELEASE_CONCURRENCY, queue.length) }, async () => {
+        for (;;) {
+            const tool = queue.shift();
+            if (tool === undefined)
+                return;
+            try {
+                const result = await api.orchestration.release.getDeployed({
+                    workflowUuid: tool.workflowUuid,
+                });
+                const formFields = result.release?.formFields;
+                const printed = printFormFieldsInput(formFields);
+                if (printed !== undefined) {
+                    tool.inputTypeSrc = printed;
+                }
+            }
+            catch {
+                // Not deployed / not accessible — keep the loose fallback type.
+            }
+        }
+    });
+    await Promise.all(workers);
+}
+function collectAgents(workspaceAgents) {
+    const out = [];
+    const used = new Set();
+    const allAgents = isAgentsResult(workspaceAgents)
+        ? workspaceAgents.agents
+        : [];
+    for (const a of allAgents) {
+        out.push({
+            slug: pickSlug(a.name, a.uuid, used),
+            name: a.name,
+            description: trimOrUndefined(a.description),
+            uuid: a.uuid,
+            updatedAt: dateToIso(a.updatedAt),
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+function isAgentsResult(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const v = value;
+    return Array.isArray(v.agents);
+}
+function collectNative(actions) {
+    const out = [];
+    for (const [slug, meta] of Object.entries(actions)) {
+        if (COMPOSITE_NATIVE.has(slug))
+            continue;
+        if (BUNDLED_NATIVE.has(slug))
+            continue;
+        const name = meta.name.length > 0 ? meta.name : slug;
+        out.push({
+            slug,
+            name,
+            description: trimOrUndefined(meta.description),
+        });
+    }
+    out.sort((a, b) => a.slug.localeCompare(b.slug));
+    return out;
+}
+function trimOrUndefined(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function dateToIso(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : value.toISOString();
+    }
+    if (typeof value === "string") {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    return undefined;
+}
+// Slugify `name` to a JS identifier; append a UUID-based suffix on collision
+// (or when the name slugifies to nothing). `used` is mutated.
+function pickSlug(name, uuid, used) {
+    const base = slugify(name);
+    if (base.length > 0 && !used.has(base)) {
+        used.add(base);
+        return base;
+    }
+    const suffix = uuid.replace(/-/g, "_");
+    const fallback = base.length > 0 ? `${base}_${suffix}` : `_${suffix}`;
+    used.add(fallback);
+    return fallback;
+}
+function slugify(name) {
+    const normalized = name
+        .normalize("NFKD")
+        .replace(/[^\w]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toLowerCase();
+    if (normalized.length === 0)
+        return "";
+    // JS identifiers can't start with a digit.
+    return /^\d/.test(normalized) ? `_${normalized}` : normalized;
+}
+const GENERATED_AT = new Date().toISOString();
+const HEADER = `// THIS FILE IS GENERATED by \`cargo-ai workflow sync\`. Do not edit by hand.
+// Re-run the command to refresh after adding/removing workspace integrations,
+// tools, or agents.
+// Last regenerated: ${GENERATED_AT}
+
+`;
+function renderTypes(payload) {
+    const lines = [];
+    lines.push(`declare module "@cargo-ai/workflow-sdk" {`);
+    if (payload.integrations.length > 0) {
+        lines.push(`  interface Integrations {`);
+        for (const c of payload.integrations) {
+            const intDoc = formatJsDoc({
+                name: c.name ?? c.slug,
+                description: c.description,
+                updatedAt: GENERATED_AT,
+            }, "    ");
+            if (intDoc !== "")
+                lines.push(intDoc.trimEnd());
+            lines.push(`    ${jsonKey(c.slug)}: {`);
+            for (const action of c.actions) {
+                const actionDoc = formatJsDoc({
+                    name: action.name,
+                    description: action.description,
+                    category: c.slug,
+                    updatedAt: GENERATED_AT,
+                }, "      ");
+                if (actionDoc !== "")
+                    lines.push(actionDoc.trimEnd());
+                lines.push(`      ${jsonKey(action.slug)}: IntegrationAction<${action.inputTypeSrc}, Record<string, unknown>>;`);
+            }
+            lines.push(`    };`);
+        }
+        lines.push(`  }`);
+    }
+    if (payload.tools.length > 0) {
+        lines.push(`  interface Tools {`);
+        for (const t of payload.tools) {
+            const doc = formatJsDoc({
+                name: t.name,
+                description: t.description,
+                updatedAt: t.updatedAt ?? GENERATED_AT,
+            }, "    ");
+            if (doc !== "")
+                lines.push(doc.trimEnd());
+            lines.push(`    ${jsonKey(t.slug)}: ToolFn<${t.inputTypeSrc}, Record<string, unknown>>;`);
+        }
+        lines.push(`  }`);
+    }
+    if (payload.agents.length > 0) {
+        lines.push(`  interface Agents {`);
+        for (const a of payload.agents) {
+            const doc = formatJsDoc({
+                name: a.name,
+                description: a.description,
+                updatedAt: a.updatedAt ?? GENERATED_AT,
+            }, "    ");
+            if (doc !== "")
+                lines.push(doc.trimEnd());
+            lines.push(`    ${jsonKey(a.slug)}: AgentFn<${AGENT_INPUT_TYPE_SRC}, AgentDefaultOutput>;`);
+        }
+        lines.push(`  }`);
+    }
+    if (payload.native.length > 0) {
+        lines.push(`  interface Native {`);
+        for (const n of payload.native) {
+            const doc = formatJsDoc({
+                name: n.name,
+                description: n.description,
+                updatedAt: GENERATED_AT,
+            }, "    ");
+            if (doc !== "")
+                lines.push(doc.trimEnd());
+            lines.push(`    ${jsonKey(n.slug)}: NativeAction<Record<string, unknown>, Record<string, unknown>>;`);
+        }
+        lines.push(`  }`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    const body = lines.join("\n");
+    // `Ref` only appears when at least one entry has a typed input, so import
+    // it conditionally to keep the generated .d.ts free of unused imports.
+    const imports = [
+        "AgentDefaultOutput",
+        "AgentFn",
+        "IntegrationAction",
+        "NativeAction",
+        ...(body.includes("Ref<") ? ["Ref"] : []),
+        "ToolFn",
+    ];
+    const header = [
+        HEADER.trim(),
+        `import type {`,
+        ...imports.map((name) => `  ${name},`),
+        `} from "@cargo-ai/workflow-sdk";`,
+        ``,
+    ].join("\n");
+    return `${header}\n${body}`;
+}
+function renderEagerRegistration(payload) {
+    const lines = [];
+    lines.push(HEADER.trim());
+    const imports = [];
+    if (payload.integrations.length > 0)
+        imports.push("registerIntegration");
+    if (payload.tools.length > 0)
+        imports.push("registerTool");
+    if (payload.agents.length > 0)
+        imports.push("registerAgent");
+    if (payload.native.length > 0)
+        imports.push("registerNative");
+    if (imports.length === 0) {
+        lines.push(``);
+        lines.push(`// Workspace surface is empty (no custom integrations / tools / agents / natives).`);
+        lines.push(``);
+        return lines.join("\n");
+    }
+    lines.push(`import { ${imports.join(", ")} } from "@cargo-ai/workflow-sdk";`);
+    lines.push(``);
+    for (const c of payload.integrations) {
+        lines.push(`registerIntegration(${JSON.stringify(c.slug)}, {`);
+        for (const action of c.actions) {
+            const displayName = action.name !== undefined && action.name.length > 0
+                ? action.name
+                : `${capitalize(c.slug)} ${humanize(action.slug)}`;
+            lines.push(`  ${jsonKey(action.slug)}: { name: ${JSON.stringify(displayName)} },`);
+        }
+        lines.push(`});`);
+    }
+    for (const t of payload.tools) {
+        lines.push(`registerTool(${JSON.stringify(t.slug)}, { toolUuid: ${JSON.stringify(t.uuid)} }, ${JSON.stringify(t.name)});`);
+    }
+    for (const a of payload.agents) {
+        lines.push(`registerAgent(${JSON.stringify(a.slug)}, { agentUuid: ${JSON.stringify(a.uuid)} }, ${JSON.stringify(a.name)});`);
+    }
+    for (const n of payload.native) {
+        lines.push(`registerNative(${JSON.stringify(n.slug)}, ${JSON.stringify(n.name)});`);
+    }
+    lines.push(``);
+    return lines.join("\n");
+}
+function jsonKey(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+// Render a JSDoc block above a generated declaration so editors surface the
+// entry's metadata on hover. Returns "" when there's nothing to document.
+function formatJsDoc(doc, indent) {
+    const body = [];
+    if (doc.name !== undefined && doc.name.trim().length > 0) {
+        body.push(doc.name.trim());
+    }
+    if (doc.description !== undefined && doc.description.trim().length > 0) {
+        if (body.length > 0)
+            body.push("");
+        for (const line of doc.description.split("\n")) {
+            body.push(line.trimEnd());
+        }
+    }
+    const tags = [];
+    if (doc.category !== undefined) {
+        const cats = Array.isArray(doc.category)
+            ? doc.category.join(", ")
+            : String(doc.category);
+        if (cats.trim().length > 0) {
+            tags.push(`@category ${cats}`);
+        }
+    }
+    if (doc.author !== undefined && doc.author.trim().length > 0) {
+        tags.push(`@author ${doc.author.trim()}`);
+    }
+    if (doc.version !== undefined && String(doc.version).length > 0) {
+        tags.push(`@version ${String(doc.version)}`);
+    }
+    if (doc.updatedAt !== undefined && doc.updatedAt !== null) {
+        const date = doc.updatedAt instanceof Date ? doc.updatedAt : new Date(doc.updatedAt);
+        if (!Number.isNaN(date.getTime())) {
+            tags.push(`@updated ${date.toISOString().slice(0, 10)}`);
+        }
+    }
+    if (doc.see !== undefined && doc.see.trim().length > 0) {
+        tags.push(`@see ${doc.see.trim()}`);
+    }
+    if (body.length > 0 && tags.length > 0) {
+        body.push("");
+    }
+    body.push(...tags);
+    if (body.length === 0)
+        return "";
+    const out = [`${indent}/**`];
+    for (const line of body) {
+        const safe = line.replace(/\*\//g, "*\\/");
+        out.push(safe.length > 0 ? `${indent} * ${safe}` : `${indent} *`);
+    }
+    out.push(`${indent} */`);
+    return `${out.join("\n")}\n`;
+}
+function capitalize(s) {
+    if (s.length === 0)
+        return s;
+    const first = s[0];
+    if (first === undefined)
+        return s;
+    return first.toUpperCase() + s.slice(1);
+}
+function humanize(slug) {
+    return slug
+        .replace(/([A-Z])/g, " $1")
+        .replace(/[_-]+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function relativeToBase(base, path) {
+    if (path.startsWith(base)) {
+        const rel = path.slice(base.length);
+        return rel.startsWith("/") ? rel.slice(1) : rel;
+    }
+    return path;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cargo-ai/cli",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "private": false,
   "description": "Command-line interface for the Cargo API",
   "engines": {
@@ -31,7 +31,8 @@
     "@cargo-ai/api": "^1.0.27",
     "@cargo-ai/app-sdk": "^1.0.0",
     "@cargo-ai/worker-sdk": "^1.0.2",
-    "commander": "^12.1.0"
+    "commander": "^12.1.0",
+    "tsx": "^4.19.2"
   },
   "devDependencies": {
     "@cargo-ai/eslint-config": "*",
@@ -40,7 +41,6 @@
     "@types/node": "^20.10.8",
     "eslint": "9.26.0",
     "prettier": "3.3.3",
-    "tsx": "^4.19.2",
     "typescript": "5.3.2"
   }
 }

package/build/commands/orchestration/draftRelease.d.ts

@@ -1,4 +0,0 @@
-import type { Command } from "commander";
-import type { Api } from "../../api.js";
-export declare function registerDraftReleaseCommands(parent: Command, getApi: () => Api): void;
-//# sourceMappingURL=draftRelease.d.ts.map

package/build/commands/orchestration/draftRelease.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"draftRelease.d.ts","sourceRoot":"","sources":["../../../src/commands/orchestration/draftRelease.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGxC,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,GAAG,GAChB,IAAI,CA8GN"}

package/build/commands/orchestration/draftRelease.js

@@ -1,73 +0,0 @@
-import { handleApiCall, outputJson, parseJson } from "../runHandler.js";
-export function registerDraftReleaseCommands(parent, getApi) {
-    const draftRelease = parent
-        .command("draft-release")
-        .description("Draft release operations");
-    draftRelease
-        .command("get")
-        .description("Get draft release for a workflow")
-        .requiredOption("--workflow-uuid <uuid>", "Workflow UUID")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.orchestration.draftRelease.get({
-            workflowUuid: opts.workflowUuid,
-        }));
-        outputJson(result);
-    });
-    draftRelease
-        .command("deploy")
-        .description("Deploy draft release")
-        .requiredOption("--workflow-uuid <uuid>", "Workflow UUID")
-        .option("--version <version>", "Release version (e.g. '1.0.0', '1.1.0', '1.0.1', etc.)")
-        .requiredOption("--nodes <json>", "Nodes (JSON array of node definitions)")
-        .requiredOption("--form-fields <json>", "Form fields (JSON array, or 'null')")
-        .option("--description <text>", "Release description")
-        .option("--options <json>", "Options (JSON object)")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.orchestration.draftRelease.deploy({
-            workflowUuid: opts.workflowUuid,
-            version: opts.version,
-            nodes: parseJson(opts.nodes, "--nodes"),
-            formFields: opts.formFields === "null"
-                ? null
-                : parseJson(opts.formFields, "--form-fields"),
-            description: opts.description,
-            options: opts.options !== undefined
-                ? parseJson(opts.options, "--options")
-                : undefined,
-        }));
-        outputJson(result);
-    });
-    draftRelease
-        .command("update")
-        .description("Update draft release")
-        .requiredOption("--workflow-uuid <uuid>", "Workflow UUID")
-        .option("--parent-uuid <uuid>", "Parent release UUID")
-        .option("--nodes <json>", "Nodes (JSON array of node definitions)")
-        .option("--test-records <json>", "Test records (JSON array)")
-        .option("--form-fields <json>", "Form fields (JSON array, or 'null')")
-        .option("--options <json>", "Options (JSON object)")
-        .action(async (opts) => {
-        const api = getApi();
-        const result = await handleApiCall(() => api.orchestration.draftRelease.update({
-            workflowUuid: opts.workflowUuid,
-            parentUuid: opts.parentUuid,
-            nodes: opts.nodes !== undefined
-                ? parseJson(opts.nodes, "--nodes")
-                : undefined,
-            testRecords: opts.testRecords !== undefined
-                ? parseJson(opts.testRecords, "--test-records")
-                : undefined,
-            formFields: opts.formFields === "null"
-                ? null
-                : opts.formFields !== undefined
-                    ? parseJson(opts.formFields, "--form-fields")
-                    : undefined,
-            options: opts.options !== undefined
-                ? parseJson(opts.options, "--options")
-                : undefined,
-        }));
-        outputJson(result);
-    });
-}