arkaos 4.26.0 → 4.27.0

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

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.SEMRUSH_API_KEY
+const BASE_URL = 'https://api.semrush.com/'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'SEMRUSH_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+function parseCSV(text) {
+  const lines = text.trim().split('\n')
+  if (lines.length < 2) return []
+  const headers = lines[0].split(';')
+  const rows = []
+  for (let i = 1; i < lines.length; i++) {
+    if (!lines[i].trim()) continue
+    const values = lines[i].split(';')
+    const row = {}
+    for (let j = 0; j < headers.length; j++) {
+      row[headers[j]] = values[j] || ''
+    }
+    rows.push(row)
+  }
+  return rows
+}
+
+async function api(params) {
+  params.set('key', API_KEY)
+  params.set('export_escape', '1')
+  if (args['dry-run']) {
+    const maskedParams = new URLSearchParams(params)
+    maskedParams.set('key', '***')
+    return { _dry_run: true, method: 'GET', url: `${BASE_URL}?${maskedParams}`, headers: {}, body: undefined }
+  }
+  const res = await fetch(`${BASE_URL}?${params}`)
+  const text = await res.text()
+  if (!res.ok) {
+    return { error: text.trim(), status: res.status }
+  }
+  if (text.startsWith('ERROR')) {
+    return { error: text.trim() }
+  }
+  return parseCSV(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 database = args.database || 'us'
+
+  switch (cmd) {
+    case 'domain':
+      switch (sub) {
+        case 'overview': {
+          if (!args.domain) { result = { error: '--domain required' }; break }
+          const params = new URLSearchParams({
+            type: 'domain_ranks',
+            export_columns: 'Db,Dn,Rk,Or,Ot,Oc,Ad,At,Ac',
+            domain: args.domain,
+          })
+          result = await api(params)
+          break
+        }
+        case 'organic': {
+          if (!args.domain) { result = { error: '--domain required' }; break }
+          const params = new URLSearchParams({
+            type: 'domain_organic',
+            export_columns: 'Ph,Po,Pp,Pd,Nq,Cp,Ur,Tr,Tc,Co,Nr',
+            domain: args.domain,
+            database,
+          })
+          if (args.limit) params.set('display_limit', args.limit)
+          result = await api(params)
+          break
+        }
+        case 'competitors': {
+          if (!args.domain) { result = { error: '--domain required' }; break }
+          const params = new URLSearchParams({
+            type: 'domain_organic_organic',
+            export_columns: 'Dn,Cr,Np,Or,Ot,Oc,Ad',
+            domain: args.domain,
+            database,
+          })
+          if (args.limit) params.set('display_limit', args.limit)
+          result = await api(params)
+          break
+        }
+        default:
+          result = { error: 'Unknown domain subcommand. Use: overview, organic, competitors' }
+      }
+      break
+
+    case 'keywords':
+      switch (sub) {
+        case 'overview': {
+          if (!args.phrase) { result = { error: '--phrase required' }; break }
+          const params = new URLSearchParams({
+            type: 'phrase_all',
+            export_columns: 'Ph,Nq,Cp,Co,Nr',
+            phrase: args.phrase,
+            database,
+          })
+          result = await api(params)
+          break
+        }
+        case 'related': {
+          if (!args.phrase) { result = { error: '--phrase required' }; break }
+          const params = new URLSearchParams({
+            type: 'phrase_related',
+            export_columns: 'Ph,Nq,Cp,Co,Nr,Td',
+            phrase: args.phrase,
+            database,
+          })
+          if (args.limit) params.set('display_limit', args.limit)
+          result = await api(params)
+          break
+        }
+        case 'difficulty': {
+          if (!args.phrase) { result = { error: '--phrase required' }; break }
+          const params = new URLSearchParams({
+            type: 'phrase_kdi',
+            export_columns: 'Ph,Kd',
+            phrase: args.phrase,
+            database,
+          })
+          result = await api(params)
+          break
+        }
+        default:
+          result = { error: 'Unknown keywords subcommand. Use: overview, related, difficulty' }
+      }
+      break
+
+    case 'backlinks':
+      switch (sub) {
+        case 'overview': {
+          const params = new URLSearchParams({
+            type: 'backlinks_overview',
+            target: args.target,
+            target_type: 'root_domain',
+          })
+          result = await api(params)
+          break
+        }
+        case 'list': {
+          const params = new URLSearchParams({
+            type: 'backlinks',
+            target: args.target,
+            target_type: 'root_domain',
+            export_columns: 'source_url,source_title,target_url,anchor',
+          })
+          if (args.limit) params.set('display_limit', args.limit)
+          result = await api(params)
+          break
+        }
+        default:
+          result = { error: 'Unknown backlinks subcommand. Use: overview, list' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          'domain overview': 'domain overview --domain <domain>',
+          'domain organic': 'domain organic --domain <domain> [--database <db>] [--limit <n>]',
+          'domain competitors': 'domain competitors --domain <domain> [--database <db>] [--limit <n>]',
+          'keywords overview': 'keywords overview --phrase <phrase> [--database <db>]',
+          'keywords related': 'keywords related --phrase <phrase> [--database <db>] [--limit <n>]',
+          'keywords difficulty': 'keywords difficulty --phrase <phrase> [--database <db>]',
+          'backlinks overview': 'backlinks overview --target <domain>',
+          'backlinks list': 'backlinks list --target <domain> [--limit <n>]',
+          'databases': 'us (default), uk, de, fr, ca, au, etc.',
+        }
+      }
+  }
+
+  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/sendgrid.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.SENDGRID_API_KEY
+const BASE_URL = 'https://api.sendgrid.com/v3'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'SENDGRID_API_KEY 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: { 'Authorization': '***', 'Content-Type': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${API_KEY}`,
+      '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 'send': {
+      if (!args.from || !args.to || !args.subject) { result = { error: '--from, --to, and --subject required' }; break }
+      const body = {
+        personalizations: [{
+          to: args.to.split(',').map(e => ({ email: e.trim() })),
+        }],
+        from: { email: args.from },
+        subject: args.subject,
+      }
+      if (args['template-id']) {
+        body.template_id = args['template-id']
+        if (args['template-data']) {
+          try { body.personalizations[0].dynamic_template_data = JSON.parse(args['template-data']) } catch (e) { result = { error: 'Invalid JSON for --template-data: ' + e.message }; break }
+        }
+      } else {
+        const content = []
+        if (args.text) content.push({ type: 'text/plain', value: args.text })
+        if (args.html) content.push({ type: 'text/html', value: args.html })
+        if (content.length > 0) body.content = content
+      }
+      if (args.cc) body.personalizations[0].cc = args.cc.split(',').map(e => ({ email: e.trim() }))
+      if (args.bcc) body.personalizations[0].bcc = args.bcc.split(',').map(e => ({ email: e.trim() }))
+      if (args['reply-to']) body.reply_to = { email: args['reply-to'] }
+      result = await api('POST', '/mail/send', body)
+      break
+    }
+
+    case 'contacts':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/marketing/contacts')
+          break
+        case 'add': {
+          const body = {
+            contacts: [{
+              email: args.email,
+            }],
+          }
+          if (args['first-name']) body.contacts[0].first_name = args['first-name']
+          if (args['last-name']) body.contacts[0].last_name = args['last-name']
+          if (args['list-ids']) body.list_ids = args['list-ids'].split(',')
+          result = await api('PUT', '/marketing/contacts', body)
+          break
+        }
+        case 'search': {
+          const body = { query: args.query }
+          result = await api('POST', '/marketing/contacts/search', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown contacts subcommand. Use: list, add, search' }
+      }
+      break
+
+    case 'campaigns':
+      switch (sub) {
+        case 'list': {
+          const params = new URLSearchParams()
+          if (args.limit) params.set('page_size', args.limit)
+          result = await api('GET', `/marketing/campaigns?${params}`)
+          break
+        }
+        case 'get':
+          if (!rest[0]) { result = { error: 'Campaign ID required' }; break }
+          result = await api('GET', `/marketing/campaigns/${rest[0]}`)
+          break
+        default:
+          result = { error: 'Unknown campaigns subcommand. Use: list, get' }
+      }
+      break
+
+    case 'stats': {
+      switch (sub) {
+        case 'get': {
+          const params = new URLSearchParams()
+          if (args['start-date']) params.set('start_date', args['start-date'])
+          if (args['end-date']) params.set('end_date', args['end-date'])
+          result = await api('GET', `/stats?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown stats subcommand. Use: get' }
+      }
+      break
+    }
+
+    case 'bounces':
+      switch (sub) {
+        case 'list': {
+          const params = new URLSearchParams()
+          if (args['start-time']) params.set('start_time', args['start-time'])
+          if (args['end-time']) params.set('end_time', args['end-time'])
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/suppression/bounces?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown bounces subcommand. Use: list' }
+      }
+      break
+
+    case 'spam-reports':
+      switch (sub) {
+        case 'list': {
+          const params = new URLSearchParams()
+          if (args['start-time']) params.set('start_time', args['start-time'])
+          if (args['end-time']) params.set('end_time', args['end-time'])
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/suppression/spam_reports?${params}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown spam-reports subcommand. Use: list' }
+      }
+      break
+
+    case 'validate':
+      switch (sub) {
+        case 'email': {
+          if (!args.email && !rest[0]) { result = { error: '--email required' }; break }
+          const body = { email: args.email || rest[0] }
+          result = await api('POST', '/validations/email', body)
+          break
+        }
+        default: {
+          const body = { email: sub }
+          result = await api('POST', '/validations/email', body)
+          break
+        }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          send: 'send --from <email> --to <email> --subject <subject> --html <html> [--text <text>] [--template-id <id>] [--template-data <json>]',
+          contacts: 'contacts [list|add|search] [--email <email>] [--first-name <name>] [--last-name <name>] [--list-ids <ids>] [--query <sgql>]',
+          campaigns: 'campaigns [list|get] [id] [--limit <n>]',
+          stats: 'stats get [--start-date <YYYY-MM-DD>] [--end-date <YYYY-MM-DD>]',
+          bounces: 'bounces list [--start-time <ts>] [--end-time <ts>] [--limit <n>]',
+          'spam-reports': 'spam-reports list [--start-time <ts>] [--end-time <ts>] [--limit <n>]',
+          validate: 'validate <email> OR validate email --email <email>',
+        }
+      }
+  }
+
+  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/similarweb.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.SIMILARWEB_API_KEY
+const BASE_URL = 'https://api.similarweb.com/v1'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'SIMILARWEB_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+async function api(method, path, body) {
+  const separator = path.includes('?') ? '&' : '?'
+  const url = `${BASE_URL}${path}${separator}api_key=${API_KEY}`
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url: url.replace(API_KEY, '***'), headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(url, {
+    method,
+    headers: {
+      '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 'traffic':
+      switch (sub) {
+        case 'visits': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          if (args.granularity) params.set('granularity', args.granularity)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/total-traffic-and-engagement/visits?${params.toString()}`)
+          break
+        }
+        case 'pages-per-visit': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          if (args.granularity) params.set('granularity', args.granularity)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/total-traffic-and-engagement/pages-per-visit?${params.toString()}`)
+          break
+        }
+        case 'avg-duration': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          if (args.granularity) params.set('granularity', args.granularity)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/total-traffic-and-engagement/average-visit-duration?${params.toString()}`)
+          break
+        }
+        case 'bounce-rate': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          if (args.granularity) params.set('granularity', args.granularity)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/total-traffic-and-engagement/bounce-rate?${params.toString()}`)
+          break
+        }
+        case 'sources': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/traffic-sources/overview?${params.toString()}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown traffic subcommand. Use: visits, pages-per-visit, avg-duration, bounce-rate, sources' }
+      }
+      break
+
+    case 'referrals': {
+      const domain = args.domain
+      if (!domain) { result = { error: '--domain required' }; break }
+      if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+      if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+      const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+      if (args.country) params.set('country', args.country)
+      result = await api('GET', `/website/${encodeURIComponent(domain)}/traffic-sources/referrals?${params.toString()}`)
+      break
+    }
+
+    case 'search':
+      switch (sub) {
+        case 'keywords-organic': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/search/organic-search-keywords?${params.toString()}`)
+          break
+        }
+        case 'keywords-paid': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+          if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+          const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+          if (args.country) params.set('country', args.country)
+          if (args.limit) params.set('limit', args.limit)
+          result = await api('GET', `/website/${encodeURIComponent(domain)}/search/paid-search-keywords?${params.toString()}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown search subcommand. Use: keywords-organic, keywords-paid' }
+      }
+      break
+
+    case 'competitors': {
+      const domain = args.domain
+      if (!domain) { result = { error: '--domain required' }; break }
+      result = await api('GET', `/website/${encodeURIComponent(domain)}/similar-sites/similarsites`)
+      break
+    }
+
+    case 'category-rank': {
+      const domain = args.domain
+      if (!domain) { result = { error: '--domain required' }; break }
+      result = await api('GET', `/website/${encodeURIComponent(domain)}/category-rank/category-rank`)
+      break
+    }
+
+    case 'geography': {
+      const domain = args.domain
+      if (!domain) { result = { error: '--domain required' }; break }
+      if (!args.start) { result = { error: '--start required (YYYY-MM)' }; break }
+      if (!args.end) { result = { error: '--end required (YYYY-MM)' }; break }
+      const params = new URLSearchParams({ start_date: args.start, end_date: args.end })
+      result = await api('GET', `/website/${encodeURIComponent(domain)}/geo/traffic-by-country?${params.toString()}`)
+      break
+    }
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          traffic: {
+            visits: 'traffic visits --domain <domain> --start <YYYY-MM> --end <YYYY-MM> [--country <cc>] [--granularity <monthly|weekly|daily>]',
+            'pages-per-visit': 'traffic pages-per-visit --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+            'avg-duration': 'traffic avg-duration --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+            'bounce-rate': 'traffic bounce-rate --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+            sources: 'traffic sources --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+          },
+          referrals: 'referrals --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+          search: {
+            'keywords-organic': 'search keywords-organic --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+            'keywords-paid': 'search keywords-paid --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+          },
+          competitors: 'competitors --domain <domain>',
+          'category-rank': 'category-rank --domain <domain>',
+          geography: 'geography --domain <domain> --start <YYYY-MM> --end <YYYY-MM>',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})