@miranda0808/maya-codex 0.1.0

package/payload/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/payload/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/payload/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)
+})