cli-jaw 0.1.0

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

@@ -0,0 +1,43 @@
+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));

package/skills_ref/whatsapp/scripts/get-graph.js

@@ -0,0 +1,85 @@
+#!/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);
+});

package/skills_ref/whatsapp/scripts/get-table.js

@@ -0,0 +1,45 @@
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/databases/kapso-api.js';
+import { hasHelpFlag, parseFlags, requireFlag, parseNumber } 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/get-table.js --table <name> [--limit <n>]',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const flags = parseFlags(argv);
+    const table = requireFlag(flags, 'table');
+    const limit = parseNumber(flags.limit, 'limit');
+    const query = limit !== undefined ? `?limit=${encodeURIComponent(String(limit))}` : '';
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(config, `/platform/v1/database_tables/${encodeURIComponent(table)}${query}`);
+    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/get-workflow.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/get-workflow.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}`
+  });
+
+  if (!response.ok) {
+    printJson(err('Failed to fetch 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);
+});

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

@@ -0,0 +1,60 @@
+import { readFileSync } from 'node:fs';
+import { kapsoConfigFromEnv, kapsoRequest } from './lib/functions/kapso-api.js';
+import { hasHelpFlag, parseFlags, requireFlag, parseJsonValue } from './lib/functions/args.js';
+
+function ok(data) {
+  return { ok: true, data };
+}
+
+function err(message, details) {
+  return { ok: false, error: { message, details } };
+}
+
+function resolvePayload(flags) {
+  if (typeof flags.payload === 'string' && flags.payload.length > 0) {
+    return parseJsonValue(flags.payload, 'payload');
+  }
+  if (typeof flags['payload-file'] === 'string' && flags['payload-file'].length > 0) {
+    return JSON.parse(readFileSync(flags['payload-file'], 'utf8'));
+  }
+  throw new Error('Provide --payload or --payload-file');
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (hasHelpFlag(argv)) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          usage:
+            'node scripts/invoke-function.js --function-id <id> (--payload <json> | --payload-file <path>)',
+          env: ['KAPSO_API_BASE_URL', 'KAPSO_API_KEY']
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+
+  try {
+    const flags = parseFlags(argv);
+    const functionId = requireFlag(flags, 'function-id');
+    const payload = resolvePayload(flags);
+    const config = kapsoConfigFromEnv();
+    const data = await kapsoRequest(config, `/platform/v1/functions/${encodeURIComponent(functionId)}/invoke`, {
+      method: 'POST',
+      body: JSON.stringify(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/lib/databases/args.js

@@ -0,0 +1,87 @@
+function hasHelpFlag(argv) {
+  return argv.includes('--help') || argv.includes('-h');
+}
+
+function parseFlags(argv) {
+  const flags = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith('--')) {
+      continue;
+    }
+    const trimmed = arg.slice(2);
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex >= 0) {
+      const key = trimmed.slice(0, eqIndex);
+      const value = trimmed.slice(eqIndex + 1);
+      flags[key] = value;
+      continue;
+    }
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+      flags[trimmed] = true;
+      continue;
+    }
+    flags[trimmed] = next;
+    index += 1;
+  }
+  return flags;
+}
+
+function requireFlag(flags, name) {
+  const value = flags[name];
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Missing required flag --${name}`);
+  }
+  return value;
+}
+
+function parseJsonObject(value, name) {
+  if (value === undefined || value === true) {
+    throw new Error(`Missing required JSON for --${name}`);
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('Expected JSON object');
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Invalid JSON for --${name}: ${String(error)}`);
+  }
+}
+
+function parseJsonObjectOptional(value, name) {
+  if (value === undefined || value === true) {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('Expected JSON object');
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Invalid JSON for --${name}: ${String(error)}`);
+  }
+}
+
+function parseNumber(value, name) {
+  if (value === undefined || value === true) {
+    return undefined;
+  }
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid number for --${name}: ${value}`);
+  }
+  return parsed;
+}
+
+export {
+  hasHelpFlag,
+  parseFlags,
+  requireFlag,
+  parseJsonObject,
+  parseJsonObjectOptional,
+  parseNumber
+};

package/skills_ref/whatsapp/scripts/lib/databases/filters.js

@@ -0,0 +1,30 @@
+import { parseJsonObjectOptional } from './args.js';
+
+function resolveFilters(flags) {
+  const filters = parseJsonObjectOptional(flags.filters, 'filters');
+  if (filters) {
+    const entries = {};
+    Object.entries(filters).forEach(([key, value]) => {
+      entries[key] = String(value);
+    });
+    return entries;
+  }
+  if (typeof flags.id === 'string' && flags.id.length > 0) {
+    return { id: `eq.${flags.id}` };
+  }
+  throw new Error('Provide --filters (JSON) or --id');
+}
+
+function filtersToQuery(filters) {
+  const params = new URLSearchParams();
+  Object.entries(filters).forEach(([key, value]) => {
+    params.set(key, value);
+  });
+  const query = params.toString();
+  return query ? `?${query}` : '';
+}
+
+export {
+  resolveFilters,
+  filtersToQuery
+};

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

@@ -0,0 +1,70 @@
+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.'
+    );
+  }
+}
+
+function kapsoConfigFromEnv() {
+  const baseUrl = normalizeBaseUrl(requireEnv('KAPSO_API_BASE_URL'));
+  validateBaseUrl(baseUrl);
+  return {
+    baseUrl,
+    apiKey: requireEnv('KAPSO_API_KEY')
+  };
+}
+
+async function kapsoRequest(config, path, init = {}) {
+  const url = `${config.baseUrl}${path}`;
+  const headers = new Headers(init.headers || undefined);
+  headers.set('X-API-Key', config.apiKey);
+  if (!headers.has('Content-Type')) {
+    headers.set('Content-Type', 'application/json');
+  }
+
+  let response;
+  try {
+    response = await fetch(url, { ...init, headers });
+  } catch (error) {
+    throw new Error(
+      `Kapso API request failed (network error) url=${url} error=${String(error?.message || error)}`
+    );
+  }
+  const text = await response.text();
+
+  if (!response.ok) {
+    throw new Error(`Kapso API request failed (status=${response.status}) body=${text}`);
+  }
+
+  return text ? JSON.parse(text) : {};
+}
+
+export {
+  kapsoConfigFromEnv,
+  kapsoRequest
+};

package/skills_ref/whatsapp/scripts/lib/functions/args.js

@@ -0,0 +1,55 @@
+function hasHelpFlag(argv) {
+  return argv.includes('--help') || argv.includes('-h');
+}
+
+function parseFlags(argv) {
+  const flags = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith('--')) {
+      continue;
+    }
+    const trimmed = arg.slice(2);
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex >= 0) {
+      const key = trimmed.slice(0, eqIndex);
+      const value = trimmed.slice(eqIndex + 1);
+      flags[key] = value;
+      continue;
+    }
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+      flags[trimmed] = true;
+      continue;
+    }
+    flags[trimmed] = next;
+    index += 1;
+  }
+  return flags;
+}
+
+function requireFlag(flags, name) {
+  const value = flags[name];
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Missing required flag --${name}`);
+  }
+  return value;
+}
+
+function parseJsonValue(value, name) {
+  if (value === undefined || value === true) {
+    throw new Error(`Missing required JSON for --${name}`);
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid JSON for --${name}: ${String(error)}`);
+  }
+}
+
+export {
+  hasHelpFlag,
+  parseFlags,
+  requireFlag,
+  parseJsonValue
+};

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

@@ -0,0 +1,70 @@
+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.'
+    );
+  }
+}
+
+function kapsoConfigFromEnv() {
+  const baseUrl = normalizeBaseUrl(requireEnv('KAPSO_API_BASE_URL'));
+  validateBaseUrl(baseUrl);
+  return {
+    baseUrl,
+    apiKey: requireEnv('KAPSO_API_KEY')
+  };
+}
+
+async function kapsoRequest(config, path, init = {}) {
+  const url = `${config.baseUrl}${path}`;
+  const headers = new Headers(init.headers || undefined);
+  headers.set('X-API-Key', config.apiKey);
+  if (!headers.has('Content-Type')) {
+    headers.set('Content-Type', 'application/json');
+  }
+
+  let response;
+  try {
+    response = await fetch(url, { ...init, headers });
+  } catch (error) {
+    throw new Error(
+      `Kapso API request failed (network error) url=${url} error=${String(error?.message || error)}`
+    );
+  }
+  const text = await response.text();
+
+  if (!response.ok) {
+    throw new Error(`Kapso API request failed (status=${response.status}) body=${text}`);
+  }
+
+  return text ? JSON.parse(text) : {};
+}
+
+export {
+  kapsoConfigFromEnv,
+  kapsoRequest
+};

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

@@ -0,0 +1,53 @@
+export function parseArgs(argv) {
+  const flags = {};
+  const args = [];
+
+  let i = 0;
+  while (i < argv.length) {
+    const token = argv[i];
+    if (token.startsWith('--')) {
+      const trimmed = token.slice(2);
+      const eqIndex = trimmed.indexOf('=');
+      if (eqIndex !== -1) {
+        const key = trimmed.slice(0, eqIndex);
+        const value = trimmed.slice(eqIndex + 1);
+        flags[key] = value;
+        i += 1;
+        continue;
+      }
+
+      const key = trimmed;
+      const next = argv[i + 1];
+      if (!next || next.startsWith('--')) {
+        flags[key] = true;
+        i += 1;
+      } else {
+        flags[key] = next;
+        i += 2;
+      }
+      continue;
+    }
+
+    args.push(token);
+    i += 1;
+  }
+
+  return { args, flags };
+}
+
+export function getFlag(flags, name) {
+  const value = flags[name];
+  if (typeof value === 'string') return value;
+  return undefined;
+}
+
+export function getBooleanFlag(flags, name) {
+  return Boolean(flags[name]);
+}
+
+export function getNumberFlag(flags, name) {
+  const value = getFlag(flags, name);
+  if (!value) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}