arkaos 4.26.0 → 4.28.0

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

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+const CLIENT_ID = process.env.SNOV_CLIENT_ID
+const CLIENT_SECRET = process.env.SNOV_CLIENT_SECRET
+const BASE_URL = 'https://api.snov.io/v1'
+
+if (!CLIENT_ID || !CLIENT_SECRET) {
+  console.error(JSON.stringify({ error: 'SNOV_CLIENT_ID and SNOV_CLIENT_SECRET environment variables required' }))
+  process.exit(1)
+}
+
+let cachedToken = null
+
+async function getToken() {
+  if (cachedToken) return cachedToken
+  const res = await fetch('https://api.snov.io/v1/oauth/access_token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ grant_type: 'client_credentials', client_id: CLIENT_ID, client_secret: CLIENT_SECRET }),
+  })
+  const data = await res.json()
+  if (!data.access_token) {
+    throw new Error(data.error_description || data.error || 'Failed to obtain access token')
+  }
+  cachedToken = data.access_token
+  return cachedToken
+}
+
+async function api(method, path, body) {
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url: `${BASE_URL}${path}`, headers: { Authorization: '***', 'Content-Type': 'application/json', Accept: 'application/json' }, body: body || undefined }
+  }
+  const token = await getToken()
+  const opts = {
+    method,
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+    },
+  }
+  if (body) opts.body = JSON.stringify(body)
+  const res = await fetch(`${BASE_URL}${path}`, opts)
+  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 'domain':
+      switch (sub) {
+        case 'search': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          const body = { domain, type: args.type || 'all', limit: Number(args.limit || 100), lastId: 0 }
+          result = await api('POST', '/get-domain-emails-with-info', body)
+          break
+        }
+        case 'count': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          result = await api('POST', '/get-domain-emails-count', { domain })
+          break
+        }
+        default:
+          result = { error: 'Unknown domain subcommand. Use: search, count' }
+      }
+      break
+
+    case 'email':
+      switch (sub) {
+        case 'find': {
+          const domain = args.domain
+          const firstName = args['first-name']
+          const lastName = args['last-name']
+          if (!domain || !firstName || !lastName) { result = { error: '--domain, --first-name, and --last-name required' }; break }
+          result = await api('POST', '/get-emails-from-names', { firstName, lastName, domain })
+          break
+        }
+        case 'verify': {
+          const email = args.email
+          if (!email) { result = { error: '--email required' }; break }
+          result = await api('POST', '/get-emails-verification-status', { emails: [email] })
+          break
+        }
+        default:
+          result = { error: 'Unknown email subcommand. Use: find, verify' }
+      }
+      break
+
+    case 'prospect':
+      switch (sub) {
+        case 'find': {
+          const email = args.email
+          if (!email) { result = { error: '--email required' }; break }
+          result = await api('POST', '/get-prospect-by-email', { email })
+          break
+        }
+        case 'add': {
+          const email = args.email
+          if (!email) { result = { error: '--email required' }; break }
+          const body = { email }
+          if (args['first-name']) body.firstName = args['first-name']
+          if (args['last-name']) body.lastName = args['last-name']
+          if (args['list-id']) body.listId = args['list-id']
+          result = await api('POST', '/add-prospect-to-list', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown prospect subcommand. Use: find, add' }
+      }
+      break
+
+    case 'lists':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/get-user-lists')
+          break
+        case 'prospects': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          const body = { listId: id }
+          if (args.page) body.page = Number(args.page)
+          if (args['per-page']) body.perPage = Number(args['per-page'])
+          result = await api('POST', '/prospect-list', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown lists subcommand. Use: list, prospects' }
+      }
+      break
+
+    case 'technology':
+      switch (sub) {
+        case 'check': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          result = await api('POST', '/get-technology-checker', { domain })
+          break
+        }
+        default:
+          result = { error: 'Unknown technology subcommand. Use: check' }
+      }
+      break
+
+    case 'drips':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/get-user-campaigns')
+          break
+        case 'get': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('GET', `/get-emails-from-campaign?id=${encodeURIComponent(id)}`)
+          break
+        }
+        case 'add-prospect': {
+          const campaignId = args['campaign-id']
+          const email = args.email
+          if (!campaignId || !email) { result = { error: '--campaign-id and --email required' }; break }
+          const body = { campaignId, email }
+          if (args['first-name']) body.firstName = args['first-name']
+          if (args['last-name']) body.lastName = args['last-name']
+          result = await api('POST', '/add-prospect-to-email-campaign', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown drips subcommand. Use: list, get, add-prospect' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          domain: {
+            search: 'domain search --domain <domain> [--type all|personal|generic] [--limit <n>]',
+            count: 'domain count --domain <domain>',
+          },
+          email: {
+            find: 'email find --domain <domain> --first-name <name> --last-name <name>',
+            verify: 'email verify --email <email>',
+          },
+          prospect: {
+            find: 'prospect find --email <email>',
+            add: 'prospect add --email <email> [--first-name <name>] [--last-name <name>] [--list-id <id>]',
+          },
+          lists: {
+            list: 'lists list',
+            prospects: 'lists prospects --id <id> [--page <n>] [--per-page <n>]',
+          },
+          technology: 'technology check --domain <domain>',
+          drips: {
+            list: 'drips list',
+            get: 'drips get --id <id>',
+            'add-prospect': 'drips add-prospect --campaign-id <id> --email <email> [--first-name <name>] [--last-name <name>]',
+          },
+        }
+      }
+  }
+
+  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/supermetrics.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.SUPERMETRICS_API_KEY
+const BASE_URL = 'https://api.supermetrics.com/enterprise/v2'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'SUPERMETRICS_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+async function api(method, path, body) {
+  const url = `${BASE_URL}${path}`
+  const headers = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json',
+    'x-api-key': API_KEY,
+  }
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url, headers: { ...headers, 'x-api-key': '***' }, body: body || undefined }
+  }
+  const res = await fetch(url, {
+    method,
+    headers,
+    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 'query': {
+      const dsId = args['ds-id']
+      const dsAccounts = args['ds-accounts']
+      const dateRange = args['date-range']
+      const fields = args.fields
+      if (!dsId) { result = { error: '--ds-id required (e.g., GA4, AW, FB, LI, GSC)' }; break }
+      if (!dsAccounts) { result = { error: '--ds-accounts required' }; break }
+      if (!dateRange) { result = { error: '--date-range required (e.g., last_28_days, last_month, this_month, custom)' }; break }
+      if (!fields) { result = { error: '--fields required (comma-separated field names)' }; break }
+      const body = {
+        ds_id: dsId,
+        ds_accounts: dsAccounts,
+        date_range_type: dateRange,
+        fields: fields.split(',').map(f => ({ name: f.trim() })),
+      }
+      if (args.filter) body.filter = args.filter
+      if (args['max-rows']) body.max_rows = parseInt(args['max-rows'], 10)
+      if (args['start-date']) body.start_date = args['start-date']
+      if (args['end-date']) body.end_date = args['end-date']
+      result = await api('POST', '/query/data/json', body)
+      break
+    }
+
+    case 'sources':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/datasources')
+          break
+        default:
+          result = { error: 'Unknown sources subcommand. Use: list' }
+      }
+      break
+
+    case 'accounts':
+      switch (sub) {
+        case 'list': {
+          const dsId = args['ds-id']
+          if (!dsId) { result = { error: '--ds-id required (e.g., GA4, AW, FB)' }; break }
+          const params = new URLSearchParams({ ds_id: dsId })
+          result = await api('GET', `/datasources/accounts?${params.toString()}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown accounts subcommand. Use: list' }
+      }
+      break
+
+    case 'teams':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/teams')
+          break
+        default:
+          result = { error: 'Unknown teams subcommand. Use: list' }
+      }
+      break
+
+    case 'users':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/users')
+          break
+        default:
+          result = { error: 'Unknown users subcommand. Use: list' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          query: 'query --ds-id <data-source> --ds-accounts <account-id> --date-range <range> --fields <f1,f2> [--filter <filter>] [--max-rows <n>] [--start-date <date>] [--end-date <date>]',
+          sources: {
+            list: 'sources list',
+          },
+          accounts: {
+            list: 'accounts list --ds-id <data-source>',
+          },
+          teams: {
+            list: 'teams list',
+          },
+          users: {
+            list: 'users list',
+          },
+          'data-source-ids': {
+            'GA4': 'Google Analytics 4',
+            'GA4_PAID': 'Google Analytics (paid)',
+            'AW': 'Google Ads',
+            'FB': 'Facebook Ads',
+            'LI': 'LinkedIn Ads',
+            'TW_ADS': 'Twitter Ads',
+            'IG_IA': 'Instagram',
+            'FB_IA': 'Facebook Pages',
+            'GSC': 'Google Search Console',
+            'SE': 'Semrush',
+            'MC': 'Mailchimp',
+          },
+          'date-ranges': ['last_28_days', 'last_month', 'this_month', 'custom'],
+        }
+      }
+  }
+
+  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/tiktok-ads.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+const TOKEN = process.env.TIKTOK_ACCESS_TOKEN
+const ADVERTISER_ID = process.env.TIKTOK_ADVERTISER_ID
+const BASE_URL = 'https://business-api.tiktok.com/open_api/v1.3'
+
+if (!TOKEN) {
+  console.error(JSON.stringify({ error: 'TIKTOK_ACCESS_TOKEN environment variable required' }))
+  process.exit(1)
+}
+
+async function api(method, path, body) {
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url: `${BASE_URL}${path}`, headers: { 'Access-Token': '***', 'Content-Type': 'application/json' }, body: body || undefined }
+  }
+  const opts = {
+    method,
+    headers: {
+      'Access-Token': TOKEN,
+      'Content-Type': 'application/json',
+    },
+  }
+  if (body && method === 'POST') {
+    opts.body = JSON.stringify(body)
+  }
+  const res = await fetch(`${BASE_URL}${path}`, opts)
+  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._
+
+function getAdvertiserId() {
+  return args['advertiser-id'] || ADVERTISER_ID
+}
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'advertiser':
+      switch (sub) {
+        case 'info': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          const advParams = new URLSearchParams({ advertiser_ids: JSON.stringify([advId]) })
+          result = await api('GET', `/advertiser/info/?${advParams}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown advertiser subcommand. Use: info' }
+      }
+      break
+
+    case 'campaigns':
+      switch (sub) {
+        case 'list': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          const campParams = new URLSearchParams({ advertiser_id: advId, page: '1', page_size: '20' })
+          result = await api('GET', `/campaign/get/?${campParams}`)
+          break
+        }
+        case 'create': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          if (!args.name || !args.objective) { result = { error: '--name and --objective required' }; break }
+          const body = {
+            advertiser_id: advId,
+            campaign_name: args.name,
+            objective_type: args.objective,
+            budget_mode: args['budget-mode'] || 'BUDGET_MODE_DAY',
+          }
+          if (args.budget) body.budget = parseFloat(args.budget)
+          result = await api('POST', '/campaign/create/', body)
+          break
+        }
+        case 'update-status': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          if (!args.ids || !args.status) { result = { error: '--ids and --status required' }; break }
+          result = await api('POST', '/campaign/status/update/', {
+            advertiser_id: advId,
+            campaign_ids: args.ids.split(','),
+            opt_status: args.status,
+          })
+          break
+        }
+        default:
+          result = { error: 'Unknown campaigns subcommand. Use: list, create, update-status' }
+      }
+      break
+
+    case 'adgroups':
+      switch (sub) {
+        case 'list': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          const agParams = new URLSearchParams({ advertiser_id: advId })
+          if (args['campaign-id']) agParams.set('campaign_ids', JSON.stringify([args['campaign-id']]))
+          result = await api('GET', `/adgroup/get/?${agParams}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown adgroups subcommand. Use: list' }
+      }
+      break
+
+    case 'reports':
+      switch (sub) {
+        case 'get': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          if (!args['start-date'] || !args['end-date']) { result = { error: '--start-date and --end-date required (YYYY-MM-DD)' }; break }
+          const body = {
+            advertiser_id: advId,
+            report_type: 'BASIC',
+            dimensions: args.dimensions ? args.dimensions.split(',') : ['campaign_id'],
+            metrics: args.metrics ? args.metrics.split(',') : ['spend', 'impressions', 'clicks', 'conversion'],
+            data_level: args['data-level'] || 'AUCTION_CAMPAIGN',
+            start_date: args['start-date'],
+            end_date: args['end-date'],
+          }
+          result = await api('POST', '/report/integrated/get/', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown reports subcommand. Use: get' }
+      }
+      break
+
+    case 'audiences':
+      switch (sub) {
+        case 'list': {
+          const advId = getAdvertiserId()
+          if (!advId) { result = { error: 'TIKTOK_ADVERTISER_ID env or --advertiser-id required' }; break }
+          const audParams = new URLSearchParams({ advertiser_id: advId })
+          result = await api('GET', `/dmp/custom_audience/list/?${audParams}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown audiences subcommand. Use: list' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          advertiser: 'advertiser [info]',
+          campaigns: 'campaigns [list|create|update-status] [--name <name>] [--objective <obj>] [--budget-mode BUDGET_MODE_DAY] [--budget <amount>] [--ids <id1,id2>] [--status ENABLE|DISABLE]',
+          adgroups: 'adgroups [list] [--campaign-id <id>]',
+          reports: 'reports [get] --start-date YYYY-MM-DD --end-date YYYY-MM-DD [--dimensions campaign_id] [--metrics spend,impressions,clicks,conversion] [--data-level AUCTION_CAMPAIGN]',
+          audiences: 'audiences [list]',
+        },
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})