arkaos 4.26.0 → 4.28.0

package/departments/marketing/tools/clis/github-prospects.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+const TOKEN = process.env.GITHUB_TOKEN
+const BASE_URL = 'https://api.github.com'
+const USER_AGENT = 'marketingskills-prospects-cli'
+
+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))
+
+async function api(path, opts = {}) {
+  const url = path.startsWith('http') ? path : `${BASE_URL}${path}`
+  const headers = {
+    'Accept': 'application/vnd.github+json',
+    'X-GitHub-Api-Version': '2022-11-28',
+    'User-Agent': USER_AGENT,
+  }
+  if (TOKEN) headers['Authorization'] = `Bearer ${TOKEN}`
+
+  if (args['dry-run']) {
+    return {
+      _dry_run: true,
+      method: 'GET',
+      url,
+      headers: { ...headers, Authorization: TOKEN ? 'Bearer ***' : undefined },
+    }
+  }
+
+  const res = await fetch(url, { headers })
+  const rateLimitRemaining = res.headers.get('x-ratelimit-remaining')
+  const rateLimitReset = res.headers.get('x-ratelimit-reset')
+
+  if (res.status === 401 || res.status === 403) {
+    const body = await res.text()
+    return {
+      error: `HTTP ${res.status}`,
+      hint: TOKEN
+        ? 'Token rejected — check GITHUB_TOKEN scopes (public_repo is enough for public data).'
+        : 'Set GITHUB_TOKEN env var to raise rate limit from 60/hr to 5000/hr.',
+      rate_limit_remaining: rateLimitRemaining,
+      rate_limit_reset_unix: rateLimitReset,
+      body,
+    }
+  }
+
+  if (!res.ok) {
+    const body = await res.text()
+    return { error: `HTTP ${res.status}`, body }
+  }
+
+  const data = await res.json()
+  const linkHeader = res.headers.get('link') || ''
+  const nextMatch = linkHeader.match(/<([^>]+)>;\s*rel="next"/)
+  return {
+    data,
+    next: nextMatch ? nextMatch[1] : null,
+    rate_limit_remaining: rateLimitRemaining,
+  }
+}
+
+async function paginate(path, { limit, perPage = 100 } = {}) {
+  const initial = path.includes('?') ? `${path}&per_page=${perPage}` : `${path}?per_page=${perPage}`
+  const all = []
+  let next = initial
+  let lastRate = null
+  while (next) {
+    const result = await api(next)
+    if (result._dry_run) return result
+    if (result.error) return result
+    lastRate = result.rate_limit_remaining
+    all.push(...result.data)
+    if (limit && all.length >= limit) {
+      return { data: all.slice(0, limit), rate_limit_remaining: lastRate, truncated: true }
+    }
+    next = result.next
+  }
+  return { data: all, rate_limit_remaining: lastRate, truncated: false }
+}
+
+async function getUser(login) {
+  const result = await api(`/users/${encodeURIComponent(login)}`)
+  if (result._dry_run || result.error) return result
+  return result.data
+}
+
+function matchesFilter(user, opts) {
+  if (!user) return false
+  if (opts['with-email'] && !user.email) return false
+  if (opts['with-company'] && !user.company) return false
+  if (opts['with-blog'] && !user.blog) return false
+  if (opts['type'] && user.type !== opts.type) return false
+  return true
+}
+
+async function enrichUsers(users, opts = {}, { concurrency = 5, targetCount } = {}) {
+  const matched = []
+  for (let i = 0; i < users.length; i += concurrency) {
+    const batch = users.slice(i, i + concurrency)
+    const profiles = await Promise.all(batch.map(u => getUser(u.login)))
+    for (const profile of profiles) {
+      if (!profile || profile.error) continue
+      if (matchesFilter(profile, opts)) matched.push(profile)
+    }
+    if (targetCount && matched.length >= targetCount) {
+      return matched.slice(0, targetCount)
+    }
+  }
+  return matched
+}
+
+function toCSV(users) {
+  const cols = ['login', 'name', 'company', 'email', 'blog', 'location', 'bio', 'twitter_username', 'public_repos', 'followers', 'created_at', 'html_url']
+  const escape = (v) => {
+    if (v === null || v === undefined) return ''
+    const s = String(v).replace(/\r?\n/g, ' ')
+    if (s.includes(',') || s.includes('"')) return `"${s.replace(/"/g, '""')}"`
+    return s
+  }
+  const lines = [cols.join(',')]
+  for (const u of users) {
+    lines.push(cols.map(c => escape(u[c])).join(','))
+  }
+  return lines.join('\n')
+}
+
+function parseRepo(input) {
+  if (!input) return null
+  const trimmed = input.replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '').replace(/\/$/, '')
+  const parts = trimmed.split('/')
+  if (parts.length < 2) return null
+  return { owner: parts[0], repo: parts[1] }
+}
+
+async function main() {
+  const [command, ...rest] = args._
+
+  let result
+
+  switch (command) {
+    case 'stargazers': {
+      const repo = parseRepo(rest[0])
+      if (!repo) { result = { error: 'Usage: stargazers <owner/repo> [--limit N] [--target N] [--enrich] [--with-email] [--with-company] [--with-blog] [--format csv|json]' }; break }
+      const limit = args.limit ? parseInt(args.limit, 10) : undefined
+      const target = args.target ? parseInt(args.target, 10) : undefined
+      const page = await paginate(`/repos/${repo.owner}/${repo.repo}/stargazers`, { limit })
+      if (page._dry_run || page.error) { result = page; break }
+      let users = page.data
+      if (args.enrich || args['with-email'] || args['with-company'] || args['with-blog'] || args.type) {
+        users = await enrichUsers(users, args, { targetCount: target })
+      }
+      if (args.format === 'csv') {
+        console.log(toCSV(users))
+        return
+      }
+      result = { count: users.length, rate_limit_remaining: page.rate_limit_remaining, truncated: page.truncated, users }
+      break
+    }
+
+    case 'forks': {
+      const repo = parseRepo(rest[0])
+      if (!repo) { result = { error: 'Usage: forks <owner/repo> [--limit N] [--target N] [--enrich] [--with-email] [--with-company] [--with-blog] [--format csv|json]' }; break }
+      const limit = args.limit ? parseInt(args.limit, 10) : undefined
+      const target = args.target ? parseInt(args.target, 10) : undefined
+      const page = await paginate(`/repos/${repo.owner}/${repo.repo}/forks`, { limit })
+      if (page._dry_run || page.error) { result = page; break }
+      const forkOwners = page.data.map(f => f.owner)
+      let users = forkOwners
+      if (args.enrich || args['with-email'] || args['with-company'] || args['with-blog'] || args.type) {
+        users = await enrichUsers(forkOwners, args, { targetCount: target })
+      }
+      if (args.format === 'csv') {
+        console.log(toCSV(users))
+        return
+      }
+      result = { count: users.length, rate_limit_remaining: page.rate_limit_remaining, truncated: page.truncated, users }
+      break
+    }
+
+    case 'watchers': {
+      const repo = parseRepo(rest[0])
+      if (!repo) { result = { error: 'Usage: watchers <owner/repo> [--limit N] [--target N] [--enrich] [--with-email] [--with-company] [--with-blog] [--format csv|json]' }; break }
+      const limit = args.limit ? parseInt(args.limit, 10) : undefined
+      const target = args.target ? parseInt(args.target, 10) : undefined
+      const page = await paginate(`/repos/${repo.owner}/${repo.repo}/subscribers`, { limit })
+      if (page._dry_run || page.error) { result = page; break }
+      let users = page.data
+      if (args.enrich || args['with-email'] || args['with-company'] || args['with-blog'] || args.type) {
+        users = await enrichUsers(users, args, { targetCount: target })
+      }
+      if (args.format === 'csv') {
+        console.log(toCSV(users))
+        return
+      }
+      result = { count: users.length, rate_limit_remaining: page.rate_limit_remaining, truncated: page.truncated, users }
+      break
+    }
+
+    case 'user': {
+      const login = rest[0]
+      if (!login) { result = { error: 'Usage: user <username>' }; break }
+      result = await getUser(login)
+      break
+    }
+
+    case 'rate-limit': {
+      const res = await api('/rate_limit')
+      result = res._dry_run || res.error ? res : res.data
+      break
+    }
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          stargazers: 'stargazers <owner/repo> [--limit N] [--target N] [--enrich] [--with-email] [--with-company] [--with-blog] [--type User|Organization] [--format csv|json]',
+          forks: 'forks <owner/repo> [--limit N] [--target N] [--enrich] [--with-email] [--with-company] [--with-blog] [--type User|Organization] [--format csv|json]',
+          watchers: 'watchers <owner/repo> [--limit N] [--target N] [--enrich] [--with-email] [--with-company] [--with-blog] [--format csv|json]',
+          user: 'user <username>',
+          'rate-limit': 'rate-limit',
+        },
+        notes: [
+          'Set GITHUB_TOKEN env var for 5000 req/hr (vs 60/hr unauthenticated).',
+          'Token needs only public_repo scope for public data; no scope is required to list public stargazers/forks.',
+          '--enrich fetches each users full profile (1 extra request per user). Use with --limit on large repos.',
+          '--with-email / --with-company / --with-blog imply --enrich.',
+          '--target N stops enrichment as soon as N users match the filters (saves API quota on restrictive filters).',
+          '--format csv outputs prospecting-ready CSV; default JSON.',
+          'Pair with Apollo, Clay, Hunter, or Truelist to fill in missing emails.',
+        ],
+      }
+  }
+
+  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/google-ads.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+const TOKEN = process.env.GOOGLE_ADS_TOKEN
+const DEV_TOKEN = process.env.GOOGLE_ADS_DEVELOPER_TOKEN
+const CUSTOMER_ID = process.env.GOOGLE_ADS_CUSTOMER_ID
+const BASE_URL = 'https://googleads.googleapis.com/v14'
+
+if (!TOKEN || !DEV_TOKEN || !CUSTOMER_ID) {
+  console.error(JSON.stringify({ error: 'GOOGLE_ADS_TOKEN, GOOGLE_ADS_DEVELOPER_TOKEN, and GOOGLE_ADS_CUSTOMER_ID environment variables 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: '***', 'developer-token': '***', 'Content-Type': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${TOKEN}`,
+      'developer-token': DEV_TOKEN,
+      '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 gaql(query) {
+  return api('POST', `/customers/${CUSTOMER_ID}/googleAds:searchStream`, { query })
+}
+
+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 daysToDateRange(days) {
+  const d = parseInt(days) || 30
+  if (d === 7) return 'LAST_7_DAYS'
+  if (d === 14) return 'LAST_14_DAYS'
+  if (d === 30) return 'LAST_30_DAYS'
+  if (d === 90) return 'LAST_90_DAYS'
+  return `LAST_${d}_DAYS`
+}
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'account':
+      switch (sub) {
+        case 'info':
+        default:
+          result = await gaql('SELECT customer.id, customer.descriptive_name FROM customer')
+      }
+      break
+
+    case 'campaigns':
+      switch (sub) {
+        case 'list':
+          result = await gaql('SELECT campaign.id, campaign.name, campaign.status, campaign_budget.amount_micros FROM campaign ORDER BY campaign.id')
+          break
+        case 'performance': {
+          const dateRange = daysToDateRange(args.days)
+          result = await gaql(`SELECT campaign.name, metrics.impressions, metrics.clicks, metrics.cost_micros, metrics.conversions FROM campaign WHERE segments.date DURING ${dateRange}`)
+          break
+        }
+        case 'pause': {
+          if (!args.id) { result = { error: '--id required' }; break }
+          result = await api('POST', `/customers/${CUSTOMER_ID}/campaigns:mutate`, {
+            operations: [{
+              update: {
+                resourceName: `customers/${CUSTOMER_ID}/campaigns/${args.id}`,
+                status: 'PAUSED',
+              },
+              updateMask: 'status',
+            }],
+          })
+          break
+        }
+        case 'enable': {
+          if (!args.id) { result = { error: '--id required' }; break }
+          result = await api('POST', `/customers/${CUSTOMER_ID}/campaigns:mutate`, {
+            operations: [{
+              update: {
+                resourceName: `customers/${CUSTOMER_ID}/campaigns/${args.id}`,
+                status: 'ENABLED',
+              },
+              updateMask: 'status',
+            }],
+          })
+          break
+        }
+        default:
+          result = { error: 'Unknown campaigns subcommand. Use: list, performance, pause, enable' }
+      }
+      break
+
+    case 'adgroups':
+      switch (sub) {
+        case 'performance': {
+          const dateRange = daysToDateRange(args.days)
+          const limit = args.limit ? ` LIMIT ${args.limit}` : ''
+          result = await gaql(`SELECT ad_group.name, metrics.impressions, metrics.clicks, metrics.conversions FROM ad_group WHERE segments.date DURING ${dateRange}${limit}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown adgroups subcommand. Use: performance' }
+      }
+      break
+
+    case 'keywords':
+      switch (sub) {
+        case 'performance': {
+          const dateRange = daysToDateRange(args.days)
+          const limit = args.limit || '50'
+          result = await gaql(`SELECT ad_group_criterion.keyword.text, metrics.impressions, metrics.clicks, metrics.average_cpc FROM keyword_view WHERE segments.date DURING ${dateRange} ORDER BY metrics.clicks DESC LIMIT ${limit}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown keywords subcommand. Use: performance' }
+      }
+      break
+
+    case 'budgets':
+      switch (sub) {
+        case 'update': {
+          if (!args.id || !args.amount) { result = { error: '--id and --amount required' }; break }
+          const amountMicros = String(Math.round(parseFloat(args.amount) * 1000000))
+          result = await api('POST', `/customers/${CUSTOMER_ID}/campaignBudgets:mutate`, {
+            operations: [{
+              update: {
+                resourceName: `customers/${CUSTOMER_ID}/campaignBudgets/${args.id}`,
+                amount_micros: amountMicros,
+              },
+              updateMask: 'amount_micros',
+            }],
+          })
+          break
+        }
+        default:
+          result = { error: 'Unknown budgets subcommand. Use: update' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          account: 'account [info]',
+          campaigns: 'campaigns [list|performance|pause|enable] [--days 30] [--id <id>]',
+          adgroups: 'adgroups [performance] [--days 30] [--limit <n>]',
+          keywords: 'keywords [performance] [--days 30] [--limit 50]',
+          budgets: 'budgets [update] --id <budget_id> --amount <dollars>',
+        },
+      }
+  }
+
+  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/google-search-console.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+const ACCESS_TOKEN = process.env.GSC_ACCESS_TOKEN
+const BASE_URL = 'https://searchconsole.googleapis.com'
+
+if (!ACCESS_TOKEN) {
+  console.error(JSON.stringify({ error: 'GSC_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: { Authorization: '***', 'Content-Type': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      'Authorization': `Bearer ${ACCESS_TOKEN}`,
+      '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._
+
+function getDefaultDates() {
+  const end = new Date()
+  end.setDate(end.getDate() - 3)
+  const start = new Date(end)
+  start.setDate(start.getDate() - 28)
+  return {
+    startDate: start.toISOString().split('T')[0],
+    endDate: end.toISOString().split('T')[0],
+  }
+}
+
+async function main() {
+  let result
+  const siteUrl = args['site-url']
+
+  switch (cmd) {
+    case 'search': {
+      if (!siteUrl) {
+        result = { error: '--site-url is required for search commands' }
+        break
+      }
+      const encodedSiteUrl = encodeURIComponent(siteUrl)
+      const defaults = getDefaultDates()
+      const body = {
+        startDate: args['start-date'] || defaults.startDate,
+        endDate: args['end-date'] || defaults.endDate,
+        rowLimit: parseInt(args.limit || '100', 10),
+      }
+
+      switch (sub) {
+        case 'query':
+          body.dimensions = ['query']
+          result = await api('POST', `/webmasters/v3/sites/${encodedSiteUrl}/searchAnalytics/query`, body)
+          break
+        case 'pages':
+          body.dimensions = ['page']
+          result = await api('POST', `/webmasters/v3/sites/${encodedSiteUrl}/searchAnalytics/query`, body)
+          break
+        case 'countries':
+          body.dimensions = ['country']
+          result = await api('POST', `/webmasters/v3/sites/${encodedSiteUrl}/searchAnalytics/query`, body)
+          break
+        default:
+          result = { error: 'Unknown search subcommand. Use: query, pages, countries' }
+      }
+      break
+    }
+
+    case 'inspect': {
+      if (!siteUrl) {
+        result = { error: '--site-url is required for inspect commands' }
+        break
+      }
+      switch (sub) {
+        case 'url':
+          if (!args.url) { result = { error: '--url required (URL to inspect)' }; break }
+          result = await api('POST', '/v1/urlInspection/index:inspect', {
+            inspectionUrl: args.url,
+            siteUrl: siteUrl,
+          })
+          break
+        default:
+          result = { error: 'Unknown inspect subcommand. Use: url' }
+      }
+      break
+    }
+
+    case 'sitemaps': {
+      if (!siteUrl) {
+        result = { error: '--site-url is required for sitemaps commands' }
+        break
+      }
+      const encodedSiteUrl = encodeURIComponent(siteUrl)
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/webmasters/v3/sites/${encodedSiteUrl}/sitemaps`)
+          break
+        case 'submit': {
+          if (!args['sitemap-url']) { result = { error: '--sitemap-url required' }; break }
+          const sitemapUrl = encodeURIComponent(args['sitemap-url'])
+          result = await api('PUT', `/webmasters/v3/sites/${encodedSiteUrl}/sitemaps/${sitemapUrl}`)
+          if (!result.body && !result.error) {
+            result = { success: true, message: 'Sitemap submitted successfully' }
+          }
+          break
+        }
+        default:
+          result = { error: 'Unknown sitemaps subcommand. Use: list, submit' }
+      }
+      break
+    }
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          'search query': 'search query --site-url <url> [--start-date <date>] [--end-date <date>] [--limit <n>]',
+          'search pages': 'search pages --site-url <url> [--start-date <date>] [--end-date <date>] [--limit <n>]',
+          'search countries': 'search countries --site-url <url> [--start-date <date>] [--end-date <date>] [--limit <n>]',
+          'inspect url': 'inspect url --site-url <url> --url <page-url>',
+          'sitemaps list': 'sitemaps list --site-url <url>',
+          'sitemaps submit': 'sitemaps submit --site-url <url> --sitemap-url <sitemap-url>',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})