arkaos 4.26.0 → 4.28.0

package/departments/marketing/tools/clis/adobe-analytics.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+const ACCESS_TOKEN = process.env.ADOBE_ACCESS_TOKEN
+const CLIENT_ID = process.env.ADOBE_CLIENT_ID
+const COMPANY_ID = process.env.ADOBE_COMPANY_ID
+
+if (!ACCESS_TOKEN || !CLIENT_ID || !COMPANY_ID) {
+  console.error(JSON.stringify({ error: 'ADOBE_ACCESS_TOKEN, ADOBE_CLIENT_ID, and ADOBE_COMPANY_ID environment variables required' }))
+  process.exit(1)
+}
+
+const BASE_URL = `https://analytics.adobe.io/api/${COMPANY_ID}`
+
+async function api(method, path, body) {
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url: `${BASE_URL}${path}`, headers: { 'Authorization': '***', 'x-api-key': '***', 'x-proxy-global-company-id': COMPANY_ID, 'Content-Type': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${ACCESS_TOKEN}`,
+      'x-api-key': CLIENT_ID,
+      'x-proxy-global-company-id': COMPANY_ID,
+      'Content-Type': 'application/json',
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  const text = await res.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { status: res.status, body: text }
+  }
+}
+
+function parseArgs(args) {
+  const result = { _: [] }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) {
+        result[key] = next
+        i++
+      } else {
+        result[key] = true
+      }
+    } else {
+      result._.push(arg)
+    }
+  }
+  return result
+}
+
+const args = parseArgs(process.argv.slice(2))
+const [cmd, sub, ...rest] = args._
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'reportsuites':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/reportsuites')
+          break
+        default:
+          result = { error: 'Unknown reportsuites subcommand. Use: list' }
+      }
+      break
+
+    case 'dimensions':
+      switch (sub) {
+        case 'list': {
+          if (!args.rsid) { result = { error: '--rsid required' }; break }
+          const params = new URLSearchParams()
+          params.set('rsid', args.rsid)
+          result = await api('GET', `/dimensions?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown dimensions subcommand. Use: list' }
+      }
+      break
+
+    case 'metrics':
+      switch (sub) {
+        case 'list': {
+          if (!args.rsid) { result = { error: '--rsid required' }; break }
+          const params = new URLSearchParams()
+          params.set('rsid', args.rsid)
+          result = await api('GET', `/metrics?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown metrics subcommand. Use: list' }
+      }
+      break
+
+    case 'reports':
+      switch (sub) {
+        case 'run': {
+          if (!args.rsid) { result = { error: '--rsid required' }; break }
+          if (!args['start-date']) { result = { error: '--start-date required' }; break }
+          if (!args['end-date']) { result = { error: '--end-date required' }; break }
+          if (!args.metrics) { result = { error: '--metrics required (comma-separated)' }; break }
+          const body = {
+            rsid: args.rsid,
+            globalFilters: [{
+              type: 'dateRange',
+              dateRange: `${args['start-date']}T00:00:00/${args['end-date']}T23:59:59`,
+            }],
+            metricContainer: {
+              metrics: args.metrics.split(',').map(m => ({ id: m.trim() })),
+            },
+          }
+          if (args.dimension) {
+            body.dimension = args.dimension
+          }
+          result = await api('POST', '/reports', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown reports subcommand. Use: run' }
+      }
+      break
+
+    case 'segments':
+      switch (sub) {
+        case 'list': {
+          const params = new URLSearchParams()
+          if (args.rsid) params.set('rsid', args.rsid)
+          result = await api('GET', `/segments?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown segments subcommand. Use: list' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          reportsuites: 'reportsuites list',
+          dimensions: 'dimensions list --rsid <report_suite_id>',
+          metrics: 'metrics list --rsid <report_suite_id>',
+          reports: 'reports run --rsid <report_suite_id> --start-date <YYYY-MM-DD> --end-date <YYYY-MM-DD> --metrics <metrics> [--dimension <dimension>]',
+          segments: 'segments list [--rsid <report_suite_id>]',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})

package/departments/marketing/tools/clis/ahrefs.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.AHREFS_API_KEY
+const BASE_URL = 'https://api.ahrefs.com/v3'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'AHREFS_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+async function api(method, path) {
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url: `${BASE_URL}${path}`, headers: { 'Authorization': '***', 'Content-Type': 'application/json' } }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json',
+    },
+  })
+  const text = await res.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { status: res.status, body: text }
+  }
+}
+
+function parseArgs(args) {
+  const result = { _: [] }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) {
+        result[key] = next
+        i++
+      } else {
+        result[key] = true
+      }
+    } else {
+      result._.push(arg)
+    }
+  }
+  return result
+}
+
+const args = parseArgs(process.argv.slice(2))
+const [cmd, sub, ...rest] = args._
+
+async function main() {
+  let result
+  const mode = args.mode || 'domain'
+
+  switch (cmd) {
+    case 'domain-rating':
+      switch (sub) {
+        case 'get': {
+          if (!args.target) { result = { error: '--target required (domain)' }; break }
+          const params = new URLSearchParams({ target: args.target })
+          result = await api('GET', `/site-explorer/domain-rating?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown domain-rating subcommand. Use: get' }
+      }
+      break
+
+    case 'backlinks':
+      switch (sub) {
+        case 'list': {
+          if (!args.target) { result = { error: '--target required (domain or URL)' }; break }
+          const params = new URLSearchParams({ target: args.target, mode })
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/site-explorer/backlinks?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown backlinks subcommand. Use: list' }
+      }
+      break
+
+    case 'refdomains':
+      switch (sub) {
+        case 'list': {
+          if (!args.target) { result = { error: '--target required (domain or URL)' }; break }
+          const params = new URLSearchParams({ target: args.target, mode })
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/site-explorer/refdomains?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown refdomains subcommand. Use: list' }
+      }
+      break
+
+    case 'keywords':
+      switch (sub) {
+        case 'organic': {
+          if (!args.target) { result = { error: '--target required (domain or URL)' }; break }
+          const params = new URLSearchParams({ target: args.target, mode })
+          if (args.country) params.set('country', args.country)
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/site-explorer/organic-keywords?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown keywords subcommand. Use: organic' }
+      }
+      break
+
+    case 'top-pages':
+      switch (sub) {
+        case 'list': {
+          if (!args.target) { result = { error: '--target required (domain or URL)' }; break }
+          const params = new URLSearchParams({ target: args.target, mode })
+          if (args.country) params.set('country', args.country)
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/site-explorer/top-pages?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown top-pages subcommand. Use: list' }
+      }
+      break
+
+    case 'keyword-overview':
+      switch (sub) {
+        case 'get': {
+          const params = new URLSearchParams({ keywords: args.keywords })
+          if (args.country) params.set('country', args.country)
+          result = await api('GET', `/keywords-explorer/overview?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown keyword-overview subcommand. Use: get' }
+      }
+      break
+
+    case 'keyword-suggestions':
+      switch (sub) {
+        case 'get': {
+          const params = new URLSearchParams({ keyword: args.keyword })
+          if (args.country) params.set('country', args.country)
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/keywords-explorer/matching-terms?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown keyword-suggestions subcommand. Use: get' }
+      }
+      break
+
+    case 'serp':
+      switch (sub) {
+        case 'get': {
+          const params = new URLSearchParams({ keyword: args.keyword })
+          if (args.country) params.set('country', args.country)
+          result = await api('GET', `/keywords-explorer/serp-overview?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown serp subcommand. Use: get' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          'domain-rating': 'domain-rating get --target <domain>',
+          'backlinks': 'backlinks list --target <domain> [--mode <mode>] [--limit <n>]',
+          'refdomains': 'refdomains list --target <domain> [--mode <mode>] [--limit <n>]',
+          'keywords': 'keywords organic --target <domain> [--country <cc>] [--limit <n>]',
+          'top-pages': 'top-pages list --target <domain> [--country <cc>] [--limit <n>]',
+          'keyword-overview': 'keyword-overview get --keywords <kw1,kw2> [--country <cc>]',
+          'keyword-suggestions': 'keyword-suggestions get --keyword <keyword> [--country <cc>] [--limit <n>]',
+          'serp': 'serp get --keyword <keyword> [--country <cc>]',
+          'modes': 'domain (default), subdomains, prefix, exact',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})

package/departments/marketing/tools/clis/airops.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.AIROPS_API_KEY
+const WORKSPACE_ID = process.env.AIROPS_WORKSPACE_ID
+const BASE_URL = 'https://api.airops.com/public_api/v1'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'AIROPS_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+if (!WORKSPACE_ID) {
+  console.error(JSON.stringify({ error: 'AIROPS_WORKSPACE_ID environment variable required' }))
+  process.exit(1)
+}
+
+async function api(method, path, body) {
+  const url = `${BASE_URL}${path}`
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url, headers: { 'Authorization': 'Bearer ***', 'Content-Type': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(url, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  const text = await res.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { status: res.status, body: text }
+  }
+}
+
+function parseArgs(args) {
+  const result = { _: [] }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) {
+        result[key] = next
+        i++
+      } else {
+        result[key] = true
+      }
+    } else {
+      result._.push(arg)
+    }
+  }
+  return result
+}
+
+const args = parseArgs(process.argv.slice(2))
+const [cmd, sub, ...rest] = args._
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'flows':
+      switch (sub) {
+        case 'list': {
+          result = await api('GET', `/workspaces/${WORKSPACE_ID}/flows`)
+          break
+        }
+        case 'get': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('GET', `/workspaces/${WORKSPACE_ID}/flows/${id}`)
+          break
+        }
+        case 'execute': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          const inputs = args.inputs
+          let parsedInputs = {}
+          if (inputs) {
+            try {
+              parsedInputs = JSON.parse(inputs)
+            } catch {
+              result = { error: '--inputs must be valid JSON' }
+              break
+            }
+          }
+          result = await api('POST', `/workspaces/${WORKSPACE_ID}/flows/${id}/execute`, { inputs: parsedInputs })
+          break
+        }
+        case 'runs': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('GET', `/workspaces/${WORKSPACE_ID}/flows/${id}/runs`)
+          break
+        }
+        case 'run-status': {
+          const runId = args['run-id']
+          if (!runId) { result = { error: '--run-id required' }; break }
+          result = await api('GET', `/workspaces/${WORKSPACE_ID}/runs/${runId}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown flows subcommand. Use: list, get, execute, runs, run-status' }
+      }
+      break
+
+    case 'workflows':
+      switch (sub) {
+        case 'list': {
+          result = await api('GET', `/workspaces/${WORKSPACE_ID}/workflows`)
+          break
+        }
+        case 'execute': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          const inputs = args.inputs
+          let parsedInputs = {}
+          if (inputs) {
+            try {
+              parsedInputs = JSON.parse(inputs)
+            } catch {
+              result = { error: '--inputs must be valid JSON' }
+              break
+            }
+          }
+          result = await api('POST', `/workspaces/${WORKSPACE_ID}/workflows/${id}/execute`, { inputs: parsedInputs })
+          break
+        }
+        default:
+          result = { error: 'Unknown workflows subcommand. Use: list, execute' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          flows: {
+            list: 'flows list',
+            get: 'flows get --id <id>',
+            execute: 'flows execute --id <id> --inputs <json>',
+            runs: 'flows runs --id <id>',
+            'run-status': 'flows run-status --run-id <id>',
+          },
+          workflows: {
+            list: 'workflows list',
+            execute: 'workflows execute --id <id> --inputs <json>',
+          },
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})

package/departments/marketing/tools/clis/amplitude.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.AMPLITUDE_API_KEY
+const SECRET_KEY = process.env.AMPLITUDE_SECRET_KEY
+const INGESTION_URL = 'https://api2.amplitude.com'
+const QUERY_URL = 'https://amplitude.com/api/2'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'AMPLITUDE_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+async function ingestApi(method, path, body) {
+  if (args['dry-run']) {
+    const maskedBody = body ? JSON.parse(JSON.stringify(body)) : undefined
+    if (maskedBody && maskedBody.api_key) maskedBody.api_key = '***'
+    return { _dry_run: true, method, url: `${INGESTION_URL}${path}`, headers: { 'Content-Type': 'application/json' }, body: maskedBody }
+  }
+  const res = await fetch(`${INGESTION_URL}${path}`, {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  })
+  const text = await res.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { status: res.status, body: text }
+  }
+}
+
+async function queryApi(method, path, params) {
+  if (!SECRET_KEY) {
+    return { error: 'AMPLITUDE_SECRET_KEY required for query/export operations' }
+  }
+  const url = params ? `${QUERY_URL}${path}?${params}` : `${QUERY_URL}${path}`
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url, headers: { 'Authorization': '***', 'Content-Type': 'application/json' } }
+  }
+  const auth = Buffer.from(`${API_KEY}:${SECRET_KEY}`).toString('base64')
+  const res = await fetch(url, {
+    method,
+    headers: {
+      'Authorization': `Basic ${auth}`,
+      'Content-Type': 'application/json',
+    },
+  })
+  const text = await res.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { status: res.status, body: text }
+  }
+}
+
+function parseArgs(args) {
+  const result = { _: [] }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      const next = args[i + 1]
+      if (next && !next.startsWith('--')) {
+        result[key] = next
+        i++
+      } else {
+        result[key] = true
+      }
+    } else {
+      result._.push(arg)
+    }
+  }
+  return result
+}
+
+const args = parseArgs(process.argv.slice(2))
+const [cmd, sub, ...rest] = args._
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'track':
+      switch (sub) {
+        case 'event': {
+          if (!args['user-id']) { result = { error: '--user-id required' }; break }
+          if (!args['event-type']) { result = { error: '--event-type required' }; break }
+          const event = {
+            user_id: args['user-id'],
+            event_type: args['event-type'],
+          }
+          if (args.properties) {
+            event.event_properties = JSON.parse(args.properties)
+          }
+          result = await ingestApi('POST', '/2/httpapi', {
+            api_key: API_KEY,
+            events: [event],
+          })
+          break
+        }
+        case 'batch': {
+          if (!args.events) { result = { error: '--events required (JSON array)' }; break }
+          const events = JSON.parse(args.events)
+          result = await ingestApi('POST', '/batch', {
+            api_key: API_KEY,
+            events,
+          })
+          break
+        }
+        default:
+          result = { error: 'Unknown track subcommand. Use: event, batch' }
+      }
+      break
+
+    case 'users':
+      switch (sub) {
+        case 'activity': {
+          if (!args['user-id']) { result = { error: '--user-id required' }; break }
+          const params = new URLSearchParams()
+          params.set('user', args['user-id'])
+          result = await queryApi('GET', '/useractivity', params)
+          break
+        }
+        default:
+          result = { error: 'Unknown users subcommand. Use: activity' }
+      }
+      break
+
+    case 'export':
+      switch (sub) {
+        case 'events': {
+          if (!args.start) { result = { error: '--start required (e.g. 20240101T00)' }; break }
+          if (!args.end) { result = { error: '--end required (e.g. 20240131T23)' }; break }
+          const params = new URLSearchParams()
+          params.set('start', args.start)
+          params.set('end', args.end)
+          result = await queryApi('GET', '/export', params)
+          break
+        }
+        default:
+          result = { error: 'Unknown export subcommand. Use: events' }
+      }
+      break
+
+    case 'retention':
+      switch (sub) {
+        case 'get': {
+          if (!args.start) { result = { error: '--start required (e.g. 20240101)' }; break }
+          if (!args.end) { result = { error: '--end required (e.g. 20240131)' }; break }
+          const params = new URLSearchParams()
+          params.set('start', args.start)
+          params.set('end', args.end)
+          if (args.event) {
+            params.set('e', JSON.stringify([{ event_type: args.event }]))
+          }
+          result = await queryApi('GET', '/retention', params)
+          break
+        }
+        default:
+          result = { error: 'Unknown retention subcommand. Use: get' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          track: 'track [event --user-id <id> --event-type <type> [--properties <json>] | batch --events <json>]',
+          users: 'users activity --user-id <id>',
+          export: 'export events --start <YYYYMMDDThh> --end <YYYYMMDDThh>',
+          retention: 'retention get --start <YYYYMMDD> --end <YYYYMMDD> [--event <type>]',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})