Automate Whatsapp

{
  "agent_node_config": {
    "node_type": "agent",
    "config": {
      "system_prompt": "Inspect the mounted repository before answering. Read the README and the most relevant files under /workspace/repos/acme-app, summarize the architecture, and then propose the smallest safe change.",
      "provider_model_id": "uuid",
      "max_iterations": 20,
      "max_tokens": 8192,
      "temperature": 0.2,
      "sandbox_enabled": true,
      "sandbox_network_mode": "allow_list",
      "sandbox_allowed_outbound_hosts": [
        "api.example.com"
      ],
      "flow_agent_resources": [
        {
          "resource_type": "github_repository",
          "repo_url": "https://github.com/acme/acme-app",
          "branch": "main",
          "pat": "github_pat_replace_me"
        }
      ],
      "flow_agent_webhooks": [],
      "flow_agent_function_tools": [],
      "flow_agent_mcp_servers": []
    }
  }
}

{
  "name": "decide-route-interactive-buttons",
  "description": "Decide node helper: route to the next edge based on vars.button_choice from an interactive button reply.",
  "code": "async function handler(request, env) {\n  const payload = await request.json();\n\n  const executionContext = payload && payload.execution_context ? payload.execution_context : {};\n  const vars = executionContext && executionContext.vars ? executionContext.vars : {};\n  const availableEdges = Array.isArray(payload && payload.available_edges) ? payload.available_edges : [];\n\n  const raw = vars.button_choice ?? vars.last_user_input;\n\n  function asString(value) {\n    if (typeof value === 'string') return value;\n    if (typeof value === 'number') return String(value);\n    if (value && typeof value === 'object') {\n      try {\n        return JSON.stringify(value);\n      } catch {\n        return null;\n      }\n    }\n    return null;\n  }\n\n  function extractChoice(value) {\n    if (!value) return null;\n\n    if (typeof value === 'string') {\n      const trimmed = value.trim();\n      if (trimmed.length === 0) return null;\n      return trimmed;\n    }\n\n    if (value && typeof value === 'object') {\n      const v = value;\n      const direct = v.button_id || v.buttonId || v.list_id || v.listId || v.id || v.choice || v.value;\n      if (typeof direct === 'string' && direct.trim().length > 0) return direct.trim();\n\n      // Common nested shapes.\n      const nested =\n        (v.interactive && (v.interactive.button_reply || v.interactive.list_reply)) ||\n        v.button_reply ||\n        v.list_reply;\n\n      if (nested && typeof nested === 'object') {\n        const nestedId = nested.id || nested.button_id || nested.list_id;\n        if (typeof nestedId === 'string' && nestedId.trim().length > 0) return nestedId.trim();\n      }\n    }\n\n    return null;\n  }\n\n  const extracted = extractChoice(raw);\n  const normalized = extracted ? extracted.toLowerCase().trim() : null;\n\n  // Map common variants to canonical edge labels.\n  const mapped = normalized === 'sale' ? 'sales' : normalized;\n\n  if (mapped && availableEdges.includes(mapped)) {\n    return new Response(JSON.stringify({ next_edge: mapped }), {\n      headers: { 'Content-Type': 'application/json' }\n    });\n  }\n\n  const fallback = availableEdges[0] || 'next';\n  const reason = {\n    extracted: extracted,\n    raw_preview: asString(raw),\n    available_edges: availableEdges\n  };\n\n  return new Response(JSON.stringify({ next_edge: fallback, vars: { decision_reason: reason } }), {\n    headers: { 'Content-Type': 'application/json' }\n  });\n}\n"
}

{
  "name": "webhook-handler",
  "description": "Store webhook payloads",
  "code": "async function handler(request, env) {\n  const payload = await request.json();\n  const key = `webhook:${Date.now()}`;\n  await env.KV.put(key, JSON.stringify({ event: payload.event, data: payload.data }));\n  return new Response(JSON.stringify({ success: true }), { headers: { 'Content-Type': 'application/json' } });\n}"
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "agent_1710000100000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "agent",
        "config": {
          "system_prompt": "You are a helpful assistant. Ask one clarifying question if needed, then call complete_task.",
          "provider_model_id": "PROVIDER_MODEL_ID_HERE",
          "max_iterations": 10,
          "temperature": 0.2
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "agent_1710000100000", "label": "next" }
  ]
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "send_template_1710000500000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "send_template",
        "config": {
          "template_id": "TEMPLATE_ID_HERE",
          "parameters": {
            "1": "{{vars.customer_name}}",
            "2": "{{vars.case_id}}"
          }
        }
      }
    },
    {
      "id": "wait_for_response_1710000504000",
      "type": "flow-node",
      "position": { "x": 120, "y": 520 },
      "data": {
        "node_type": "wait_for_response",
        "config": {
          "save_response_to": "user_reply"
        }
      }
    },
    {
      "id": "agent_1710000508000",
      "type": "flow-node",
      "position": { "x": 120, "y": 720 },
      "data": {
        "node_type": "agent",
        "config": {
          "system_prompt": "You are following up on a WhatsApp template message triggered by an API call. Use vars.case_id and vars.customer_name for context. The user's reply is in vars.user_reply. Resolve the request or gather the missing details. When complete, summarize and call complete_task.",
          "provider_model_id": "PROVIDER_MODEL_ID_HERE",
          "max_iterations": 20,
          "temperature": 0.2
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "send_template_1710000500000", "label": "next" },
    { "source": "send_template_1710000500000", "target": "wait_for_response_1710000504000", "label": "next" },
    { "source": "wait_for_response_1710000504000", "target": "agent_1710000508000", "label": "next" }
  ]
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "send_text_1710000200000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Thanks for reaching out. Please reply with your email and a short description of the issue.",
          "delay_seconds": 0
        }
      }
    },
    {
      "id": "wait_for_response_1710000204000",
      "type": "flow-node",
      "position": { "x": 120, "y": 520 },
      "data": {
        "node_type": "wait_for_response",
        "config": {
          "save_response_to": "support_intake"
        }
      }
    },
    {
      "id": "agent_1710000208000",
      "type": "flow-node",
      "position": { "x": 120, "y": 720 },
      "data": {
        "node_type": "agent",
        "config": {
          "system_prompt": "You are a customer support agent. The user's intake message is in vars.support_intake. Extract the email and issue summary. Ask concise follow-up questions if critical details are missing. When you have enough info, summarize the issue and call complete_task.",
          "provider_model_id": "PROVIDER_MODEL_ID_HERE",
          "max_iterations": 20,
          "temperature": 0.2
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "send_text_1710000200000", "label": "next" },
    { "source": "send_text_1710000200000", "target": "wait_for_response_1710000204000", "label": "next" },
    { "source": "wait_for_response_1710000204000", "target": "agent_1710000208000", "label": "next" }
  ]
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "send_text_1710000010000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Do you want to continue? Reply yes or no.",
          "delay_seconds": 0
        }
      }
    },
    {
      "id": "wait_for_response_1710000014000",
      "type": "flow-node",
      "position": { "x": 120, "y": 520 },
      "data": {
        "node_type": "wait_for_response",
        "config": {
          "save_response_to": "user_reply"
        }
      }
    },
    {
      "id": "decide_1710000018000",
      "type": "flow-node",
      "position": { "x": 120, "y": 720 },
      "data": {
        "node_type": "decide",
        "config": {
          "decision_type": "function",
          "function_id": "FUNCTION_ID_HERE",
          "conditions": [
            { "label": "yes", "description": "User agreed" },
            { "label": "no", "description": "User declined" }
          ]
        }
      }
    },
    {
      "id": "send_text_1710000022000",
      "type": "flow-node",
      "position": { "x": 0, "y": 920 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Great, let's continue!",
          "delay_seconds": 0
        }
      }
    },
    {
      "id": "send_text_1710000026000",
      "type": "flow-node",
      "position": { "x": 240, "y": 920 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "No problem. Ending the workflow.",
          "delay_seconds": 0
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "send_text_1710000010000", "label": "next" },
    { "source": "send_text_1710000010000", "target": "wait_for_response_1710000014000", "label": "next" },
    { "source": "wait_for_response_1710000014000", "target": "decide_1710000018000", "label": "next" },
    { "source": "decide_1710000018000", "target": "send_text_1710000022000", "label": "yes" },
    { "source": "decide_1710000018000", "target": "send_text_1710000026000", "label": "no" }
  ]
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "send_interactive_1710000400000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "send_interactive",
        "config": {
          "interactive_type": "button",
          "body_text": "How can we help you today?",
          "buttons": [
            { "id": "sales", "title": "Sales" },
            { "id": "support", "title": "Support" }
          ]
        }
      }
    },
    {
      "id": "wait_for_response_1710000404000",
      "type": "flow-node",
      "position": { "x": 120, "y": 520 },
      "data": {
        "node_type": "wait_for_response",
        "config": {
          "save_response_to": "button_choice"
        }
      }
    },
    {
      "id": "decide_1710000408000",
      "type": "flow-node",
      "position": { "x": 120, "y": 720 },
      "data": {
        "node_type": "decide",
        "config": {
          "decision_type": "ai",
          "provider_model_id": "PROVIDER_MODEL_ID_HERE",
          "conditions": [
            { "label": "sales", "description": "User selected Sales (button id: sales)" },
            { "label": "support", "description": "User selected Support (button id: support)" }
          ],
          "llm_temperature": 0.0
        }
      }
    },
    {
      "id": "send_text_1710000412000",
      "type": "flow-node",
      "position": { "x": 0, "y": 920 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Got it - connecting you to Sales.",
          "delay_seconds": 0
        }
      }
    },
    {
      "id": "send_text_1710000416000",
      "type": "flow-node",
      "position": { "x": 240, "y": 920 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Got it - connecting you to Support.",
          "delay_seconds": 0
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "send_interactive_1710000400000", "label": "next" },
    { "source": "send_interactive_1710000400000", "target": "wait_for_response_1710000404000", "label": "next" },
    { "source": "wait_for_response_1710000404000", "target": "decide_1710000408000", "label": "next" },
    { "source": "decide_1710000408000", "target": "send_text_1710000412000", "label": "sales" },
    { "source": "decide_1710000408000", "target": "send_text_1710000416000", "label": "support" }
  ]
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "send_interactive_1710000300000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "send_interactive",
        "config": {
          "interactive_type": "button",
          "body_text": "How can we help you today?",
          "buttons": [
            { "id": "sales", "title": "Sales" },
            { "id": "support", "title": "Support" }
          ]
        }
      }
    },
    {
      "id": "wait_for_response_1710000304000",
      "type": "flow-node",
      "position": { "x": 120, "y": 520 },
      "data": {
        "node_type": "wait_for_response",
        "config": {
          "save_response_to": "button_choice"
        }
      }
    },
    {
      "id": "decide_1710000308000",
      "type": "flow-node",
      "position": { "x": 120, "y": 720 },
      "data": {
        "node_type": "decide",
        "config": {
          "decision_type": "function",
          "function_id": "FUNCTION_ID_HERE",
          "conditions": [
            { "label": "sales", "description": "User selected Sales" },
            { "label": "support", "description": "User selected Support" }
          ]
        }
      }
    },
    {
      "id": "send_text_1710000312000",
      "type": "flow-node",
      "position": { "x": 0, "y": 920 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Got it - connecting you to Sales.",
          "delay_seconds": 0
        }
      }
    },
    {
      "id": "send_text_1710000316000",
      "type": "flow-node",
      "position": { "x": 240, "y": 920 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Got it - connecting you to Support.",
          "delay_seconds": 0
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "send_interactive_1710000300000", "label": "next" },
    { "source": "send_interactive_1710000300000", "target": "wait_for_response_1710000304000", "label": "next" },
    { "source": "wait_for_response_1710000304000", "target": "decide_1710000308000", "label": "next" },
    { "source": "decide_1710000308000", "target": "send_text_1710000312000", "label": "sales" },
    { "source": "decide_1710000308000", "target": "send_text_1710000316000", "label": "support" }
  ]
}

{
  "nodes": [
    {
      "id": "start",
      "type": "flow-node",
      "position": { "x": 120, "y": 120 },
      "data": {
        "node_type": "start",
        "config": {}
      }
    },
    {
      "id": "send_text_1710000000000",
      "type": "flow-node",
      "position": { "x": 120, "y": 320 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Hello! What's your name?",
          "delay_seconds": 0
        }
      }
    },
    {
      "id": "wait_for_response_1710000005000",
      "type": "flow-node",
      "position": { "x": 120, "y": 520 },
      "data": {
        "node_type": "wait_for_response",
        "config": {
          "save_response_to": "user_name"
        }
      }
    },
    {
      "id": "send_text_1710000009000",
      "type": "flow-node",
      "position": { "x": 120, "y": 720 },
      "data": {
        "node_type": "send_text",
        "config": {
          "message": "Nice to meet you, {{vars.user_name}}!",
          "delay_seconds": 0
        }
      }
    }
  ],
  "edges": [
    { "source": "start", "target": "send_text_1710000000000", "label": "next" },
    { "source": "send_text_1710000000000", "target": "wait_for_response_1710000005000", "label": "next" },
    { "source": "wait_for_response_1710000005000", "target": "send_text_1710000009000", "label": "next" }
  ]
}

{
  "private": true,
  "type": "module",
  "dependencies": {
    "yaml": "^2.6.0"
  },
  "scripts": {
    "openapi": "node scripts/openapi-explore.mjs"
  }
}

import { readFileSync } from 'node:fs';
import { kapsoConfigFromEnv, kapsoRequest } from './lib/functions/kapso-api.js';
import {
  hasHelpFlag,
  parseBooleanFlag,
  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>] [--public-endpoint <true|false>]',
          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 };
    const publicEndpoint = parseBooleanFlag(flags, 'public-endpoint');
    if (typeof flags.description === 'string' && flags.description.length > 0) {
      payload.description = flags.description;
    }
    if (publicEndpoint !== undefined) {
      payload.public_endpoint = publicEndpoint;
    }
    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));

#!/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);
});

#!/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);
});

#!/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/delete-trigger.js --trigger-id <id>',
    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 triggerId = getFlag(parsed.flags, 'trigger-id');
  if (!triggerId) {
    printJson(err('trigger-id is required'));
    return 2;
  }

  const config = loadConfig();
  const response = await requestJson(config, {
    method: 'DELETE',
    path: `/platform/v1/triggers/${triggerId}`
  });

  if (!response.ok) {
    printJson(err('Failed to delete trigger', response.raw, false, response.status));
    return 2;
  }

  printJson(ok({ deleted: true, status: response.status }));
  return 0;
}

main().catch((error) => {
  printJson(err('Unhandled error', { message: String(error?.message || error) }));
  process.exit(1);
});

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 } };
}

async function main() {
  const argv = process.argv.slice(2);
  if (hasHelpFlag(argv)) {
    console.log(
      JSON.stringify(
        {
          ok: true,
          usage: 'node scripts/deploy-function.js --function-id <id>',
          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
        },
        null,
        2
      )
    );
    return 0;
  }

  try {
    const flags = parseFlags(argv);
    const functionId = requireFlag(flags, 'function-id');
    const config = kapsoConfigFromEnv();
    const data = await kapsoRequest(config, `/platform/v1/functions/${encodeURIComponent(functionId)}/deploy`, {
      method: 'POST',
      body: JSON.stringify({})
    });

    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));

#!/usr/bin/env node
import { createHash } from 'crypto';
import { readFileSync } from 'fs';
import { loadConfig, requestJson } from './lib/workflows/kapso-api.js';
import { ok, err, printJson } from './lib/workflows/result.js';
import { parseArgs, getFlag, getBooleanFlag, getNumberFlag } from './lib/workflows/args.js';

function sha256(text) {
  return createHash('sha256').update(text).digest('hex');
}

function normalizeLineEndings(text) {
  return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
}

function stripCodeFences(text) {
  const trimmed = text.trim();
  if (trimmed.startsWith('```')) {
    const withoutFirst = trimmed.replace(/^```[a-zA-Z0-9_-]*\n?/, '');
    return withoutFirst.replace(/```$/, '').trim();
  }
  return text;
}

function stripLineNumbers(text) {
  return text
    .split('\n')
    .map((line) => line.replace(/^\s*\d+\s*\|\s?/, '').replace(/^\s*\d+:\s?/, ''))
    .join('\n');
}

function normalizeEditText(text) {
  return normalizeLineEndings(stripLineNumbers(stripCodeFences(text)));
}

function readFileText(path) {
  return readFileSync(path, 'utf8');
}

function loadTextInput(flags, valueFlag, fileFlag) {
  const filePath = getFlag(flags, fileFlag);
  if (filePath) {
    return readFileText(filePath);
  }
  return getFlag(flags, valueFlag);
}

function isEscaped(text, index) {
  let backslashes = 0;
  for (let i = index - 1; i >= 0 && text[i] === '\\'; i -= 1) {
    backslashes += 1;
  }
  return backslashes % 2 === 1;
}

function insideJsonString(text, index) {
  let inString = false;
  for (let i = 0; i < index; i += 1) {
    if (text[i] === '"' && !isEscaped(text, i)) {
      inString = !inString;
    }
  }
  return inString;
}

function unescapeCLike(text) {
  return text
    .replace(/\\n/g, '\n')
    .replace(/\\r/g, '\r')
    .replace(/\\t/g, '\t')
    .replace(/\\"/g, '"')
    .replace(/\\\\/g, '\\');
}

function jsonStringContent(text) {
  const json = JSON.stringify(text);
  return json.slice(1, -1);
}

function replaceAllOccurrences(content, search, newText) {
  let result = '';
  let index = 0;
  let replacementsInJson = 0;
  let replacementsOutsideJson = 0;

  while (true) {
    const matchIndex = content.indexOf(search, index);
    if (matchIndex === -1) {
      result += content.slice(index);
      break;
    }

    const insideString = insideJsonString(content, matchIndex);
    const replacement = insideString
      ? jsonStringContent(unescapeCLike(newText))
      : newText;

    result += content.slice(index, matchIndex) + replacement;
    index = matchIndex + search.length;

    if (insideString) {
      replacementsInJson += 1;
    } else {
      replacementsOutsideJson += 1;
    }
  }

  return {
    content: result,
    replacements: replacementsInJson + replacementsOutsideJson,
    replacements_in_json_strings: replacementsInJson,
    replacements_outside_json_strings: replacementsOutsideJson
  };
}

function applyReplacement(content, oldText, newText, replaceAll) {
  if (oldText === newText) {
    throw new Error('old and new text must be different');
  }

  const candidates = [
    { label: 'raw', value: oldText },
    { label: 'unescaped', value: oldText.replace(/\\n/g, '\n') },
    { label: 'escaped', value: oldText.replace(/\n/g, '\\n') }
  ];

  const seen = new Set();
  const uniqueCandidates = candidates.filter((candidate) => {
    if (seen.has(candidate.value)) return false;
    seen.add(candidate.value);
    return true;
  });

  for (const candidate of uniqueCandidates) {
    if (!candidate.value) continue;
    const firstIndex = content.indexOf(candidate.value);
    if (firstIndex === -1) continue;

    if (replaceAll) {
      const replaced = replaceAllOccurrences(content, candidate.value, newText);
      return { ...replaced, matchedVariant: candidate.label };
    }

    const lastIndex = content.lastIndexOf(candidate.value);
    if (firstIndex !== lastIndex) {
      throw new Error('old text matches multiple locations; use --replace-all or narrow the match');
    }

    const insideString = insideJsonString(content, firstIndex);
    const replacement = insideString
      ? jsonStringContent(unescapeCLike(newText))
      : newText;

    const updated = content.replace(candidate.value, replacement);
    return {
      content: updated,
      replacements: 1,
      replacements_in_json_strings: insideString ? 1 : 0,
      replacements_outside_json_strings: insideString ? 0 : 1,
      matchedVariant: candidate.label
    };
  }

  throw new Error('old text not found in workflow graph');
}

function usage() {
  return ok({
    usage: 'node scripts/edit-graph.js <workflow-id> --expected-lock-version <n> --old <text>|--old-file <path> --new <text>|--new-file <path> [--replace-all]',
    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 workflowId = parsed.args[0] || getFlag(parsed.flags, 'workflow-id');
  if (!workflowId) {
    printJson(err('workflow_id is required'));
    return 2;
  }

  const expectedLockVersion = getNumberFlag(parsed.flags, 'expected-lock-version')
    ?? getNumberFlag(parsed.flags, 'lock-version');
  if (expectedLockVersion === undefined) {
    printJson(err('expected-lock-version is required'));
    return 2;
  }

  const oldInput = loadTextInput(parsed.flags, 'old', 'old-file');
  const newInput = loadTextInput(parsed.flags, 'new', 'new-file');
  if (!oldInput || !newInput) {
    printJson(err('old/new text is required (use --old/--new or --old-file/--new-file)'));
    return 2;
  }

  const replaceAll = getBooleanFlag(parsed.flags, 'replace-all');

  const config = loadConfig();
  const response = await requestJson(config, {
    method: 'GET',
    path: `/platform/v1/workflows/${workflowId}/definition`
  });

  if (!response.ok) {
    printJson(err('Failed to fetch workflow definition', response.raw, false, response.status));
    return 2;
  }

  const workflow = response.data;
  const definition = workflow && typeof workflow === 'object' ? workflow.definition : null;
  if (!definition || typeof definition !== 'object') {
    printJson(err('Workflow definition missing in response', response.raw, false, response.status));
    return 2;
  }

  const currentLock = workflow.lock_version;
  if (currentLock !== expectedLockVersion) {
    printJson(err('Conflict: workflow was modified. Refetch and retry.', {
      expected_lock_version: expectedLockVersion,
      current_lock_version: currentLock
    }));
    return 2;
  }

  const pretty = JSON.stringify(definition, null, 2);
  const beforeHash = sha256(pretty);
  const oldText = normalizeEditText(oldInput);
  const newText = normalizeEditText(newInput);

  let editResult;
  try {
    editResult = applyReplacement(pretty, oldText, newText, replaceAll);
  } catch (error) {
    printJson(err(String(error?.message || error)));
    return 2;
  }

  let updatedDefinition;
  try {
    updatedDefinition = JSON.parse(editResult.content);
  } catch (error) {
    printJson(err('Invalid JSON after replacement', { message: String(error?.message || error) }));
    return 2;
  }

  const update = await requestJson(config, {
    method: 'PATCH',
    path: `/platform/v1/workflows/${workflowId}`,
    body: {
      workflow: {
        definition: updatedDefinition
      }
    }
  });

  if (!update.ok) {
    printJson(err('Failed to update workflow definition', update.raw, false, update.status));
    return 2;
  }

  printJson(ok({
    workflow_id: workflowId,
    replacements_count: editResult.replacements,
    replacements_in_json_strings: editResult.replacements_in_json_strings,
    replacements_outside_json_strings: editResult.replacements_outside_json_strings,
    matched_variant: editResult.matchedVariant,
    workflow_graph_sha256_before: beforeHash,
    workflow_graph_sha256_after: sha256(editResult.content),
    update: {
      id: update.data.id,
      name: update.data.name,
      status: update.data.status,
      lock_version: update.data.lock_version,
      updated_at: update.data.updated_at
    }
  }));

  return 0;
}

main().catch((error) => {
  printJson(err('Unhandled error', { message: String(error?.message || error) }));
  process.exit(1);
});

#!/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/get-context-value.js <execution-id> --variable-path <path>',
    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY'],
    examples: ['node scripts/get-context-value.js exec_123 --variable-path vars.user_name']
  });
}

function getPathValue(obj, path) {
  if (!path) return undefined;
  const parts = path.split('.').filter(Boolean);
  let current = obj;
  for (const part of parts) {
    if (current && Object.prototype.hasOwnProperty.call(current, part)) {
      current = current[part];
    } else {
      return undefined;
    }
  }
  return current;
}

async function main() {
  const parsed = parseArgs(process.argv.slice(2));
  if (getBooleanFlag(parsed.flags, 'help') || getBooleanFlag(parsed.flags, 'h')) {
    printJson(usage());
    return 0;
  }

  const executionId = parsed.args[0] || getFlag(parsed.flags, 'execution-id');
  if (!executionId) {
    printJson(err('execution_id is required'));
    return 2;
  }

  const variablePath = getFlag(parsed.flags, 'variable-path');
  if (!variablePath) {
    printJson(err('variable-path is required'));
    return 2;
  }

  const config = loadConfig();
  const response = await requestJson(config, {
    method: 'GET',
    path: `/platform/v1/workflow_executions/${executionId}`
  });

  if (!response.ok) {
    printJson(err('Failed to fetch execution', response.raw, false, response.status));
    return 2;
  }

  const execution = response.data;
  const executionContext = execution && execution.execution_context ? execution.execution_context : {};
  let path = variablePath;

  if (path.startsWith('execution_context.')) {
    path = path.replace(/^execution_context\./, '');
  }

  const value = getPathValue(executionContext, path);

  if (value === undefined) {
    printJson(err('Path not found in execution_context', { variable_path: variablePath }));
    return 2;
  }

  printJson(ok({ value, variable_path: variablePath, execution_id: executionId }));
  return 0;
}

main().catch((error) => {
  printJson(err('Unhandled error', { message: String(error?.message || error) }));
  process.exit(1);
});

#!/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/get-execution-event.js <event-id> [--event-id <id>]',
    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 eventId = parsed.args[0] || getFlag(parsed.flags, 'event-id');
  if (!eventId) {
    printJson(err('event_id is required'));
    return 2;
  }

  const config = loadConfig();
  const response = await requestJson(config, {
    method: 'GET',
    path: `/platform/v1/workflow_events/${eventId}`
  });

  if (!response.ok && response.status === 404) {
    printJson(err('Execution event detail endpoint is not available in the Platform API.', {
      endpoint: '/platform/v1/workflow_events/:id'
    }, true, response.status));
    return 2;
  }

  if (!response.ok) {
    printJson(err('Failed to fetch execution event detail', response.raw, false, response.status));
    return 2;
  }

  printJson(ok({
    event_id: eventId,
    event: response.data
  }));

  return 0;
}

main().catch((error) => {
  printJson(err('Unhandled error', { message: String(error?.message || error) }));
  process.exit(1);
});

#!/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/get-execution.js <execution-id> [--execution-id <id>]',
    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 executionId = parsed.args[0] || getFlag(parsed.flags, 'execution-id');
  if (!executionId) {
    printJson(err('execution_id is required'));
    return 2;
  }

  const config = loadConfig();
  const response = await requestJson(config, {
    method: 'GET',
    path: `/platform/v1/workflow_executions/${executionId}`
  });

  if (!response.ok) {
    printJson(err('Failed to fetch execution', response.raw, false, response.status));
    return 2;
  }

  printJson(ok({ execution: response.data }));
  return 0;
}

main().catch((error) => {
  printJson(err('Unhandled error', { message: String(error?.message || error) }));
  process.exit(1);
});

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 } };
}

async function main() {
  const argv = process.argv.slice(2);
  if (hasHelpFlag(argv)) {
    console.log(
      JSON.stringify(
        {
          ok: true,
          usage: 'node scripts/get-function.js --function-id <id>',
          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
        },
        null,
        2
      )
    );
    return 0;
  }

  try {
    const flags = parseFlags(argv);
    const functionId = requireFlag(flags, 'function-id');
    const config = kapsoConfigFromEnv();
    const data = await kapsoRequest(config, `/platform/v1/functions/${encodeURIComponent(functionId)}`);
    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));

#!/usr/bin/env node
import { createHash } from 'crypto';
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 sha256(text) {
  return createHash('sha256').update(text).digest('hex');
}

function addLineNumbers(text) {
  return text
    .split('\n')
    .map((line, index) => `${String(index + 1).padStart(4, ' ')} | ${line}`)
    .join('\n');
}

function usage() {
  return ok({
    usage: 'node scripts/get-graph.js <workflow-id> [--workflow-id <id>]',
    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 workflowId = parsed.args[0] || getFlag(parsed.flags, 'workflow-id');
  if (!workflowId) {
    printJson(err('workflow_id is required'));
    return 2;
  }

  const config = loadConfig();
  const response = await requestJson(config, {
    method: 'GET',
    path: `/platform/v1/workflows/${workflowId}/definition`
  });

  if (!response.ok) {
    printJson(err('Failed to fetch workflow definition', response.raw, false, response.status));
    return 2;
  }

  const workflow = response.data;
  const definition = workflow && typeof workflow === 'object' ? workflow.definition : null;
  if (!definition || typeof definition !== 'object') {
    printJson(err('Workflow definition missing in response', response.raw, false, response.status));
    return 2;
  }

  const pretty = JSON.stringify(definition, null, 2);
  const hash = sha256(pretty);
  const withLines = addLineNumbers(pretty);

  const trimmedWorkflow = {
    id: workflow.id,
    name: workflow.name,
    description: workflow.description,
    status: workflow.status,
    lock_version: workflow.lock_version,
    message_debounce_seconds: workflow.message_debounce_seconds,
    project_id: workflow.project_id,
    updated_at: workflow.updated_at
  };

  printJson(ok({
    workflow: trimmedWorkflow,
    definition,
    workflow_graph_pretty: pretty,
    workflow_graph_with_lines: withLines,
    workflow_graph_sha256: hash
  }));

  return 0;
}

main().catch((error) => {
  printJson(err('Unhandled error', { message: String(error?.message || error) }));
  process.exit(1);
});