cli-jaw 0.1.0

package/skills_ref/whatsapp/references/workflow-reference.md

@@ -0,0 +1,123 @@
+# Reference
+
+## Overview
+
+This skill manages workflow graphs, triggers, executions, and app integrations over the Platform API and provides local graph validation. Variables CRUD is not supported and will return blocked responses.
+
+## Environment
+
+Required env vars:
+
+- `KAPSO_API_BASE_URL` (host only, no `/platform/v1`, example: `https://api.kapso.ai`)
+- `KAPSO_API_KEY`
+
+## Scripts
+
+Each script is a single operation. Run with `node` or `bun`.
+
+- `scripts/get-graph.js`
+- `scripts/list-workflows.js`
+- `scripts/get-workflow.js`
+- `scripts/create-workflow.js`
+- `scripts/update-workflow-settings.js`
+- `scripts/edit-graph.js`
+- `scripts/update-graph.js`
+- `scripts/validate-graph.js`
+- `scripts/list-triggers.js`
+- `scripts/create-trigger.js`
+- `scripts/update-trigger.js`
+- `scripts/delete-trigger.js`
+- `scripts/list-executions.js`
+- `scripts/get-execution.js`
+- `scripts/get-context-value.js`
+- `scripts/update-execution-status.js`
+- `scripts/resume-execution.js`
+- `scripts/variables-list.js`
+- `scripts/variables-set.js` (blocked)
+- `scripts/variables-delete.js` (blocked)
+- `scripts/list-provider-models.js`
+- `scripts/list-execution-events.js`
+- `scripts/get-execution-event.js`
+- `scripts/list-apps.js`
+- `scripts/search-actions.js`
+- `scripts/get-action-schema.js`
+- `scripts/list-accounts.js`
+- `scripts/create-connect-token.js`
+- `scripts/configure-prop.js`
+- `scripts/reload-props.js`
+- `scripts/list-integrations.js`
+- `scripts/create-integration.js`
+- `scripts/update-integration.js`
+- `scripts/delete-integration.js`
+- `scripts/list-whatsapp-phone-numbers.js`
+
+## Platform API endpoints
+
+Implemented calls:
+
+- `GET /platform/v1/workflows`
+- `POST /platform/v1/workflows`
+- `GET /platform/v1/workflows/:id`
+- `GET /platform/v1/workflows/:id/definition` (fetch graph definition)
+- `PATCH /platform/v1/workflows/:id` (update settings/definition)
+- `GET /platform/v1/workflows/:id/variables` (workflow variable discovery)
+- `GET /platform/v1/workflows/:workflow_id/triggers`
+- `POST /platform/v1/workflows/:workflow_id/triggers`
+- `PATCH /platform/v1/triggers/:id`
+- `DELETE /platform/v1/triggers/:id`
+- `GET /platform/v1/workflows/:workflow_id/executions`
+- `GET /platform/v1/workflow_executions/:id`
+- `PATCH /platform/v1/workflow_executions/:id`
+- `POST /platform/v1/workflow_executions/:id/resume`
+- `GET /platform/v1/workflow_executions/:id/events`
+- `GET /platform/v1/workflow_events/:id`
+- `GET /platform/v1/provider_models`
+- `GET /platform/v1/integrations`
+- `POST /platform/v1/integrations`
+- `PATCH /platform/v1/integrations/:id`
+- `DELETE /platform/v1/integrations/:id`
+- `GET /platform/v1/integrations/apps`
+- `GET /platform/v1/integrations/actions`
+- `GET /platform/v1/integrations/accounts`
+- `POST /platform/v1/integrations/connect_token`
+- `GET /platform/v1/integrations/actions/:action_id/schema`
+- `POST /platform/v1/integrations/actions/:action_id/configure_prop`
+- `POST /platform/v1/integrations/actions/:action_id/reload_props`
+- `GET /platform/v1/whatsapp/phone_numbers` (for inbound_message triggers)
+
+Variables CRUD endpoints are not defined for Platform API. Scripts intentionally return blocked for create/update/delete operations.
+
+## Workflow graphs: endpoints, shapes, and roundtrips
+
+- `GET /platform/v1/workflows/:id` returns workflow metadata (including `lock_version`) but does NOT include `definition`.
+- `GET /platform/v1/workflows/:id/definition` returns a workflow record that includes `definition` (nodes + edges).
+- `PATCH /platform/v1/workflows/:id` accepts either `workflow: { ... }` or `flow: { ... }` envelopes.
+  - To update the graph: send `workflow: { definition: <definition> }`.
+
+Graph shapes:
+- `get-graph.js` returns a ReactFlow-style definition that includes extra/computed fields (`node.type`, `data.display_name`, `edge.id`, `edge.type`).
+- The API accepts a minimal editable definition (`nodes[].id/position/data.node_type/data.config` and `edges[].source/target/label`) and ignores/strips extra fields.
+
+Source of truth: `references/graph-contract.md`.
+
+## Phone number lookup for triggers
+
+Use `scripts/list-whatsapp-phone-numbers.js` to find `phone_number_id` for inbound_message triggers.
+Do not use `/whatsapp_configs` (not a Platform API endpoint).
+
+## Graph validation rules (local)
+
+The `scripts/validate-graph.js` script checks:
+
+- Exactly one start node with `id` = `start` and `data.node_type` = `start`.
+- Unique node IDs and valid edge source/target IDs.
+- Non-empty edge labels.
+- Only `decide` nodes may branch; other nodes may have 0 or 1 outgoing `next` edge.
+- Decide node condition labels must match outgoing edge labels.
+
+Warnings are emitted for unknown node types or extra decide edges. Treat warnings as blockers before you PATCH a graph.
+
+## Assets
+
+- `assets/workflow-linear.json` (simple linear example)
+- `assets/workflow-decision.json` (wait + decide example)

package/skills_ref/whatsapp/scripts/configure-prop.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import { loadConfig, requestJson } from './lib/workflows/kapso-api.js';
+import { ok, err, printJson } from './lib/workflows/result.js';
+import { parseArgs, getFlag, getBooleanFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/configure-prop.js --action-id <id> --prop-name <name> --account-id <id> [--configured-props <json>] [--dynamic-props-id <id>]',
+    notes: [
+      'Use accounts[].pipedream_account_id for --account-id.',
+      'If you pass an internal account UUID, the script will try to resolve it.'
+    ],
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+function parseJson(value, label) {
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid JSON for ${label}: ${String(error?.message || error)}`);
+  }
+}
+
+function normalizeAccounts(payload) {
+  if (Array.isArray(payload?.accounts)) return payload.accounts;
+  if (Array.isArray(payload?.accounts?.accounts)) return payload.accounts.accounts;
+  if (Array.isArray(payload)) return payload;
+  return [];
+}
+
+async function resolveAccountId(config, accountId) {
+  if (accountId.startsWith('apn_')) return accountId;
+
+  const response = await requestJson(config, {
+    method: 'GET',
+    path: '/platform/v1/integrations/accounts'
+  });
+
+  if (!response.ok) {
+    throw new Error('Unable to resolve account id. Use list-accounts and pass pipedream_account_id.');
+  }
+
+  const accounts = normalizeAccounts(response.data);
+  const match = accounts.find((account) => account.id === accountId);
+  if (match?.pipedream_account_id) return match.pipedream_account_id;
+
+  throw new Error('account-id must be pipedream_account_id (use list-accounts output).');
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (getBooleanFlag(parsed.flags, 'help') || getBooleanFlag(parsed.flags, 'h')) {
+    printJson(usage());
+    return 0;
+  }
+
+  const actionId = getFlag(parsed.flags, 'action-id');
+  const propName = getFlag(parsed.flags, 'prop-name');
+  const accountId = getFlag(parsed.flags, 'account-id');
+
+  if (!actionId || !propName || !accountId) {
+    printJson(err('action-id, prop-name, and account-id are required'));
+    return 2;
+  }
+
+  let configuredProps = {};
+  try {
+    const provided = parseJson(getFlag(parsed.flags, 'configured-props'), 'configured-props');
+    configuredProps = provided || {};
+  } catch (error) {
+    printJson(err('Failed to parse configured-props', { message: error.message }));
+    return 2;
+  }
+
+  const config = loadConfig();
+  let resolvedAccountId = accountId;
+
+  try {
+    resolvedAccountId = await resolveAccountId(config, accountId);
+  } catch (error) {
+    printJson(err('Failed to resolve account-id', { message: error.message }));
+    return 2;
+  }
+
+  if (!Object.keys(configuredProps).length) {
+    configuredProps = { account_id: resolvedAccountId };
+  }
+
+  const response = await requestJson(config, {
+    method: 'POST',
+    path: `/platform/v1/integrations/actions/${actionId}/configure_prop`,
+    body: {
+      prop_name: propName,
+      configured_props: configuredProps,
+      dynamic_props_id: getFlag(parsed.flags, 'dynamic-props-id')
+    }
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to configure prop', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ result: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/create-connect-token.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { loadConfig, requestJson } from './lib/workflows/kapso-api.js';
+import { ok, err, printJson } from './lib/workflows/result.js';
+import { parseArgs, getBooleanFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/create-connect-token.js',
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (getBooleanFlag(parsed.flags, 'help') || getBooleanFlag(parsed.flags, 'h')) {
+    printJson(usage());
+    return 0;
+  }
+
+  const config = loadConfig();
+  const response = await requestJson(config, {
+    method: 'POST',
+    path: '/platform/v1/integrations/connect_token'
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to create connect token', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ connect_token: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/create-function.js

@@ -0,0 +1,64 @@
+import { readFileSync } from 'node:fs';
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/functions/kapso-api.js';
+import { hasHelpFlag, parseFlags, requireFlag } from './lib/functions/args.js';
+
+function ok(data) {
+  return { ok: true, data };
+}
+
+function err(message, details) {
+  return { ok: false, error: { message, details } };
+}
+
+function resolveCode(flags) {
+  if (typeof flags.code === 'string' && flags.code.length > 0) {
+    return flags.code;
+  }
+  if (typeof flags['code-file'] === 'string' && flags['code-file'].length > 0) {
+    return readFileSync(flags['code-file'], 'utf8');
+  }
+  throw new Error('Provide --code or --code-file');
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (hasHelpFlag(argv)) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          usage:
+            'node scripts/create-function.js --name <name> (--code <js> | --code-file <path>) [--description <text>]',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const flags = parseFlags(argv);
+    const name = requireFlag(flags, 'name');
+    const code = resolveCode(flags);
+    const payload = { name, code };
+    if (typeof flags.description === 'string' && flags.description.length > 0) {
+      payload.description = flags.description;
+    }
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(config, '/platform/v1/functions', {
+      method: 'POST',
+      body: JSON.stringify({ function: payload })
+    });
+
+    console.log(JSON.stringify(ok(data), null, 2));
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(JSON.stringify(err('Command failed', { message }), null, 2));
+    return 1;
+  }
+}
+
+main().then((code) => process.exit(code));

package/skills_ref/whatsapp/scripts/create-integration.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { loadConfig, requestJson } from './lib/workflows/kapso-api.js';
+import { ok, err, printJson } from './lib/workflows/result.js';
+import { parseArgs, getFlag, getBooleanFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/create-integration.js --action-id <id> --app-slug <slug> --account-id <id> [--configured-props <json>] [--name <text>] [--app-name <text>] [--variable-definitions <json>] [--dynamic-props-id <id>]',
+    notes: [
+      'Use accounts[].pipedream_account_id for --account-id.',
+      'If you pass an internal account UUID, the script will try to resolve it.',
+      'Use --variable-definitions to define agent tool inputs (placeholders in configured_props become inputs).'
+    ],
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+function parseJson(value, label) {
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid JSON for ${label}: ${String(error?.message || error)}`);
+  }
+}
+
+function ensureAccountId(props, accountId) {
+  if (!props || !Object.keys(props).length) {
+    return { account_id: accountId };
+  }
+  if (!props.account_id && !props.accountId) {
+    return { ...props, account_id: accountId };
+  }
+  return props;
+}
+
+function normalizeAccounts(payload) {
+  if (Array.isArray(payload?.accounts)) return payload.accounts;
+  if (Array.isArray(payload?.accounts?.accounts)) return payload.accounts.accounts;
+  if (Array.isArray(payload)) return payload;
+  return [];
+}
+
+async function resolveAccountId(config, appSlug, accountId) {
+  if (accountId.startsWith('apn_')) return accountId;
+
+  const response = await requestJson(config, {
+    method: 'GET',
+    path: '/platform/v1/integrations/accounts',
+    query: { app_slug: appSlug }
+  });
+
+  if (!response.ok) {
+    throw new Error('Unable to resolve account id. Use list-accounts and pass pipedream_account_id.');
+  }
+
+  const accounts = normalizeAccounts(response.data);
+  const match = accounts.find((account) => account.id === accountId);
+  if (match?.pipedream_account_id) return match.pipedream_account_id;
+
+  throw new Error('account-id must be pipedream_account_id (use list-accounts output).');
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (getBooleanFlag(parsed.flags, 'help') || getBooleanFlag(parsed.flags, 'h')) {
+    printJson(usage());
+    return 0;
+  }
+
+  const actionId = getFlag(parsed.flags, 'action-id');
+  const appSlug = getFlag(parsed.flags, 'app-slug');
+  const accountId = getFlag(parsed.flags, 'account-id');
+
+  if (!actionId || !appSlug || !accountId) {
+    printJson(err('action-id, app-slug, and account-id are required'));
+    return 2;
+  }
+
+  let configuredProps;
+  let variableDefinitions;
+
+  try {
+    configuredProps = parseJson(getFlag(parsed.flags, 'configured-props'), 'configured-props');
+    variableDefinitions = parseJson(getFlag(parsed.flags, 'variable-definitions'), 'variable-definitions');
+  } catch (error) {
+    printJson(err('Failed to parse JSON', { message: error.message }));
+    return 2;
+  }
+
+  const config = loadConfig();
+  let resolvedAccountId = accountId;
+
+  try {
+    resolvedAccountId = await resolveAccountId(config, appSlug, accountId);
+  } catch (error) {
+    printJson(err('Failed to resolve account-id', { message: error.message }));
+    return 2;
+  }
+
+  configuredProps = ensureAccountId(configuredProps, resolvedAccountId);
+
+  const payload = {
+    action_id: actionId,
+    app_slug: appSlug,
+    account_id: resolvedAccountId,
+    configured_props: configuredProps
+  };
+
+  const name = getFlag(parsed.flags, 'name');
+  const appName = getFlag(parsed.flags, 'app-name');
+  const dynamicPropsId = getFlag(parsed.flags, 'dynamic-props-id');
+
+  if (name) payload.name = name;
+  if (appName) payload.app_name = appName;
+  if (dynamicPropsId) payload.dynamic_props_id = dynamicPropsId;
+  if (variableDefinitions) payload.variable_definitions = variableDefinitions;
+
+  const response = await requestJson(config, {
+    method: 'POST',
+    path: '/platform/v1/integrations',
+    body: payload
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to create integration', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ integration: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/create-row.js

@@ -0,0 +1,47 @@
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/databases/kapso-api.js';
+import { hasHelpFlag, parseFlags, requireFlag, parseJsonObject } from './lib/databases/args.js';
+
+function ok(data) {
+  return { ok: true, data };
+}
+
+function err(message, details) {
+  return { ok: false, error: { message, details } };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (hasHelpFlag(argv)) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          usage: 'node scripts/create-row.js --table <name> --data <json>',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const flags = parseFlags(argv);
+    const table = requireFlag(flags, 'table');
+    const dataPayload = parseJsonObject(flags.data, 'data');
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(config, `/platform/v1/db/${encodeURIComponent(table)}`, {
+      method: 'POST',
+      body: JSON.stringify(dataPayload)
+    });
+    console.log(JSON.stringify(ok(data), null, 2));
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(JSON.stringify(err('Command failed', { message }), null, 2));
+    return 1;
+  }
+}
+
+main().then((code) => process.exit(code));

package/skills_ref/whatsapp/scripts/create-trigger.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { loadConfig, requestJson } from './lib/workflows/kapso-api.js';
+import { ok, err, printJson } from './lib/workflows/result.js';
+import { parseArgs, getFlag, getBooleanFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/create-trigger.js <workflow-id> --trigger-type <inbound_message|api_call|whatsapp_event> [--phone-number-id <id>] [--event <whatsapp.event>] [--active true|false] [--triggerable-attributes <json>]',
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+function parseBoolean(value) {
+  if (value === undefined) return undefined;
+  if (value === true) return true;
+  const lowered = String(value).toLowerCase();
+  if (lowered === 'true') return true;
+  if (lowered === 'false') return false;
+  return undefined;
+}
+
+function parseJson(value) {
+  if (!value) return undefined;
+  return JSON.parse(value);
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (getBooleanFlag(parsed.flags, 'help') || getBooleanFlag(parsed.flags, 'h')) {
+    printJson(usage());
+    return 0;
+  }
+
+  const workflowId = parsed.args[0] || getFlag(parsed.flags, 'workflow-id');
+  if (!workflowId) {
+    printJson(err('workflow_id is required'));
+    return 2;
+  }
+
+  const triggerType = getFlag(parsed.flags, 'trigger-type');
+  if (!triggerType) {
+    printJson(err('trigger-type is required'));
+    return 2;
+  }
+
+  const active = parseBoolean(getFlag(parsed.flags, 'active'));
+  const phoneNumberId = getFlag(parsed.flags, 'phone-number-id');
+  const whatsappConfigId = getFlag(parsed.flags, 'whatsapp-config-id');
+  const event = getFlag(parsed.flags, 'event');
+
+  let triggerableAttributes;
+  try {
+    triggerableAttributes = parseJson(getFlag(parsed.flags, 'triggerable-attributes'));
+  } catch (error) {
+    printJson(err('Invalid JSON for triggerable-attributes', { message: String(error?.message || error) }));
+    return 2;
+  }
+
+  const triggerPayload = {
+    trigger_type: triggerType
+  };
+
+  if (active !== undefined) triggerPayload.active = active;
+  if (phoneNumberId) triggerPayload.phone_number_id = phoneNumberId;
+  if (whatsappConfigId) triggerPayload.whatsapp_config_id = whatsappConfigId;
+  if (event) triggerPayload.event = event;
+  if (triggerableAttributes) triggerPayload.triggerable_attributes = triggerableAttributes;
+
+  const config = loadConfig();
+  const response = await requestJson(config, {
+    method: 'POST',
+    path: `/platform/v1/workflows/${workflowId}/triggers`,
+    body: { trigger: triggerPayload }
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to create trigger', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ trigger: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/create-workflow.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { loadConfig, requestJson } from './lib/workflows/kapso-api.js';
+import { ok, err, printJson } from './lib/workflows/result.js';
+import { parseArgs, getFlag, getBooleanFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/create-workflow.js --name <name> [--description <text>] [--definition-file <path> | --definition-json <json>]',
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+function loadDefinition({ filePath, jsonText }) {
+  if (filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  }
+  if (jsonText) {
+    return JSON.parse(jsonText);
+  }
+  return undefined;
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (getBooleanFlag(parsed.flags, 'help') || getBooleanFlag(parsed.flags, 'h')) {
+    printJson(usage());
+    return 0;
+  }
+
+  const name = getFlag(parsed.flags, 'name');
+  if (!name) {
+    printJson(err('name is required'));
+    return 2;
+  }
+
+  const description = getFlag(parsed.flags, 'description');
+  const definitionFile = getFlag(parsed.flags, 'definition-file');
+  const definitionJson = getFlag(parsed.flags, 'definition-json');
+
+  if (definitionFile && definitionJson) {
+    printJson(err('Provide only one of --definition-file or --definition-json'));
+    return 2;
+  }
+
+  let definition;
+  try {
+    definition = loadDefinition({ filePath: definitionFile, jsonText: definitionJson });
+  } catch (error) {
+    printJson(err('Failed to parse workflow definition JSON', { message: String(error?.message || error) }));
+    return 2;
+  }
+
+  const payload = {
+    workflow: {
+      name,
+      description
+    }
+  };
+
+  if (definition) {
+    payload.workflow.definition = definition;
+  }
+
+  const config = loadConfig();
+  const response = await requestJson(config, {
+    method: 'POST',
+    path: '/platform/v1/workflows',
+    body: payload
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to create workflow', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ workflow: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});