cli-jaw 0.1.0

package/skills_ref/whatsapp/scripts/lib/workflows/kapso-api.js

@@ -0,0 +1,123 @@
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required env var: ${name}`);
+  }
+  return value;
+}
+
+function normalizeBaseUrl(raw) {
+  return raw.replace(/\/+$/, '');
+}
+
+function isLocalhost(hostname) {
+  return hostname === 'localhost' || hostname === '127.0.0.1';
+}
+
+function validateBaseUrl(baseUrl) {
+  if (!baseUrl) return;
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch (error) {
+    throw new Error(`Invalid KAPSO_API_BASE_URL: ${baseUrl}`);
+  }
+  if (!process.env.KAPSO_API_ALLOW_LOCALHOST && isLocalhost(parsed.hostname)) {
+    throw new Error(
+      `KAPSO_API_BASE_URL points to localhost (${parsed.hostname}). ` +
+      'Set KAPSO_API_ALLOW_LOCALHOST=true if this is intentional.'
+    );
+  }
+}
+
+export function loadConfig(options = {}) {
+  const requireApi = options.requireApi !== false;
+
+  const rawBaseUrl = requireApi ? requireEnv('KAPSO_API_BASE_URL') : (process.env.KAPSO_API_BASE_URL || '');
+  const baseUrl = rawBaseUrl ? normalizeBaseUrl(rawBaseUrl) : '';
+  validateBaseUrl(baseUrl);
+  const apiKey = requireApi ? requireEnv('KAPSO_API_KEY') : (process.env.KAPSO_API_KEY || '');
+
+  return { baseUrl, apiKey };
+}
+
+function buildUrl(baseUrl, path) {
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  const safePath = path.startsWith('/') ? path.slice(1) : path;
+  return `${trimmed}/${safePath}`;
+}
+
+export async function requestJson(config, options) {
+  const url = new URL(buildUrl(config.baseUrl, options.path));
+
+  if (options.query) {
+    Object.entries(options.query).forEach(([key, value]) => {
+      if (value === undefined || value === null || value === '') return;
+      url.searchParams.set(key, String(value));
+    });
+  }
+
+  const headers = {
+    Accept: 'application/json'
+  };
+
+  if (config.apiKey) {
+    headers['X-API-Key'] = config.apiKey;
+  }
+
+  let body;
+  if (options.body !== undefined) {
+    headers['Content-Type'] = 'application/json';
+    body = JSON.stringify(options.body);
+  }
+
+  let response;
+  try {
+    response = await fetch(url.toString(), {
+      method: options.method,
+      headers,
+      body
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      status: 0,
+      error: 'Network error while calling Kapso API',
+      raw: { message: String(error?.message || error), url: url.toString() }
+    };
+  }
+
+  const text = await response.text();
+  let parsed = text;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
+    }
+  }
+
+  if (response.ok) {
+    const data = (parsed && typeof parsed === 'object' && 'data' in parsed)
+      ? parsed.data
+      : parsed;
+
+    return {
+      ok: true,
+      status: response.status,
+      data,
+      raw: parsed
+    };
+  }
+
+  const message = (parsed && typeof parsed === 'object' && 'error' in parsed)
+    ? String(parsed.error)
+    : `HTTP ${response.status}`;
+
+  return {
+    ok: false,
+    status: response.status,
+    error: message,
+    raw: parsed
+  };
+}

package/skills_ref/whatsapp/scripts/lib/workflows/result.js

@@ -0,0 +1,16 @@
+export function ok(data) {
+  return { ok: true, data };
+}
+
+export function err(message, details, blocked, status) {
+  const error = { message };
+  if (details !== undefined) error.details = details;
+  if (blocked !== undefined) error.blocked = blocked;
+  if (status !== undefined) error.status = status;
+  return { ok: false, error };
+}
+
+export function printJson(value) {
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(value, null, 2));
+}

package/skills_ref/whatsapp/scripts/list-accounts.js

@@ -0,0 +1,62 @@
+#!/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/list-accounts.js [--app-slug <slug>]',
+    notes: [
+      'Use accounts[].pipedream_account_id for any --account-id flag.',
+      'The internal accounts[].id will not work for integrations.'
+    ],
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+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 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: 'GET',
+    path: '/platform/v1/integrations/accounts',
+    query: {
+      app_slug: getFlag(parsed.flags, 'app-slug')
+    }
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to list accounts', response.raw, false, response.status));
+    return 2;
+  }
+
+  const raw = response.data;
+  const accounts = normalizeAccounts(raw).map((account) => ({
+    ...account,
+    preferred_account_id: account.pipedream_account_id
+  }));
+  const payload = Array.isArray(raw) ? accounts : { ...raw, accounts };
+
+  printJson(ok({
+    accounts: payload,
+    note: 'Use preferred_account_id (pipedream_account_id) for create-integration/configure-prop.'
+  }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-apps.js

@@ -0,0 +1,42 @@
+#!/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, getNumberFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/list-apps.js [--query <text>] [--limit <n>]',
+    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: 'GET',
+    path: '/platform/v1/integrations/apps',
+    query: {
+      query: getFlag(parsed.flags, 'query'),
+      limit: getNumberFlag(parsed.flags, 'limit')
+    }
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to list apps', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ apps: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-execution-events.js

@@ -0,0 +1,61 @@
+#!/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, getNumberFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage:
+      'node scripts/list-execution-events.js <execution-id> [--event-type <type>] [--page <n>] [--per-page <n>]',
+    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}/events`,
+    query: {
+      event_type: getFlag(parsed.flags, 'event-type'),
+      page: getNumberFlag(parsed.flags, 'page') ?? getNumberFlag(parsed.flags, 'offset'),
+      per_page: getNumberFlag(parsed.flags, 'per-page') ?? getNumberFlag(parsed.flags, 'limit')
+    }
+  });
+
+  if (!response.ok && response.status === 404) {
+    printJson(err('Execution events endpoint is not available in the Platform API.', {
+      endpoint: '/platform/v1/workflow_executions/:id/events'
+    }, true, response.status));
+    return 2;
+  }
+
+  if (!response.ok) {
+    printJson(err('Failed to fetch execution events', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({
+    execution_id: executionId,
+    events: response.data
+  }));
+
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-executions.js

@@ -0,0 +1,53 @@
+#!/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, getNumberFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/list-executions.js <workflow-id> [--status <status>] [--waiting-reason <value>] [--whatsapp-conversation-id <id>] [--created-after <iso>] [--created-before <iso>] [--page <n>] [--per-page <n>]',
+    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}/executions`,
+    query: {
+      status: getFlag(parsed.flags, 'status'),
+      waiting_reason: getFlag(parsed.flags, 'waiting-reason'),
+      whatsapp_conversation_id: getFlag(parsed.flags, 'whatsapp-conversation-id'),
+      created_after: getFlag(parsed.flags, 'created-after'),
+      created_before: getFlag(parsed.flags, 'created-before'),
+      page: getNumberFlag(parsed.flags, 'page'),
+      per_page: getNumberFlag(parsed.flags, 'per-page')
+    }
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to list executions', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ executions: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-function-invocations.js

@@ -0,0 +1,53 @@
+import { hasHelpFlag, parseFlags, requireFlag } from './lib/functions/args.js';
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/functions/kapso-api.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/list-function-invocations.js --function-id <id> [--status <success|failed>] [--limit <n>]',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const flags = parseFlags(argv);
+    const functionId = requireFlag(flags, 'function-id');
+    const params = new URLSearchParams();
+
+    if (flags.status) params.set('status', flags.status);
+    if (flags.limit) params.set('limit', flags.limit);
+
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(
+      config,
+      `/platform/v1/functions/${encodeURIComponent(functionId)}/invocations${params.toString() ? `?${params.toString()}` : ''}`
+    );
+
+    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/list-functions.js

@@ -0,0 +1,41 @@
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/functions/kapso-api.js';
+import { hasHelpFlag } 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/list-functions.js',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(config, '/platform/v1/functions');
+    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/list-integrations.js

@@ -0,0 +1,41 @@
+#!/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/list-integrations.js',
+    notes: [
+      'Check integrations[].variable_definitions to see required tool inputs.'
+    ],
+    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: 'GET',
+    path: '/platform/v1/integrations'
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to list integrations', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ integrations: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-provider-models.js

@@ -0,0 +1,48 @@
+#!/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/list-provider-models.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: 'GET',
+    path: '/platform/v1/provider_models'
+  });
+
+  if (!response.ok && response.status === 404) {
+    printJson(err('Provider models endpoint is not available in the Platform API.', {
+      endpoint: '/platform/v1/provider_models'
+    }, true, response.status));
+    return 2;
+  }
+
+  if (!response.ok) {
+    printJson(err('Failed to fetch provider models', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({
+    provider_models: response.data
+  }));
+
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-tables.js

@@ -0,0 +1,41 @@
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/databases/kapso-api.js';
+import { hasHelpFlag } 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/list-tables.js',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(config, '/platform/v1/database_tables');
+    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/list-triggers.js

@@ -0,0 +1,44 @@
+#!/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/list-triggers.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}/triggers`
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to list triggers', response.raw, false, response.status));
+    return 2;
+  }
+
+  printJson(ok({ triggers: response.data }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});

package/skills_ref/whatsapp/scripts/list-whatsapp-phone-numbers.js

@@ -0,0 +1,56 @@
+#!/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, getNumberFlag } from './lib/workflows/args.js';
+
+function usage() {
+  return ok({
+    usage: 'node scripts/list-whatsapp-phone-numbers.js [--per-page <n>] [--page <n>]',
+    env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+  });
+}
+
+function extractPhoneNumbers(payload) {
+  if (Array.isArray(payload?.data)) return payload.data;
+  if (Array.isArray(payload?.phone_numbers)) return payload.phone_numbers;
+  if (Array.isArray(payload)) return payload;
+  return [];
+}
+
+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: 'GET',
+    path: '/platform/v1/whatsapp/phone_numbers',
+    query: {
+      per_page: getNumberFlag(parsed.flags, 'per-page'),
+      page: getNumberFlag(parsed.flags, 'page')
+    }
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to list WhatsApp phone numbers', response.raw, false, response.status));
+    return 2;
+  }
+
+  const payload = response.data;
+  const phoneNumbers = extractPhoneNumbers(payload);
+
+  printJson(ok({
+    phone_numbers: phoneNumbers,
+    raw: payload,
+    note: 'Use phone_number_id for inbound_message triggers.'
+  }));
+  return 0;
+}
+
+main().catch((error) => {
+  printJson(err('Unhandled error', { message: String(error?.message || error) }));
+  process.exit(1);
+});