@miranda0808/maya-codex 0.1.0

package/payload/tools/clis/partnerstack.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+
+const PUBLIC_KEY = process.env.PARTNERSTACK_PUBLIC_KEY
+const SECRET_KEY = process.env.PARTNERSTACK_SECRET_KEY
+const BASE_URL = 'https://api.partnerstack.com/api/v2'
+
+if (!PUBLIC_KEY || !SECRET_KEY) {
+  console.error(JSON.stringify({ error: 'PARTNERSTACK_PUBLIC_KEY and PARTNERSTACK_SECRET_KEY environment variables required' }))
+  process.exit(1)
+}
+
+const AUTH = 'Basic ' + Buffer.from(`${PUBLIC_KEY}:${SECRET_KEY}`).toString('base64')
+
+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 res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers: {
+      'Authorization': AUTH,
+      '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._
+const limit = args.limit ? Number(args.limit) : 10
+
+function buildQuery() {
+  const params = new URLSearchParams()
+  if (args.limit) params.set('limit', args.limit)
+  if (args.after) params.set('starting_after', args.after)
+  if (args.before) params.set('ending_before', args.before)
+  if (args['order-by']) params.set('order_by', args['order-by'])
+  return params.toString() ? `?${params.toString()}` : ''
+}
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'partnerships':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/partnerships${buildQuery()}`)
+          break
+        case 'get': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (partnership key)' }; break }
+          result = await api('GET', `/partnerships/${key}`)
+          break
+        }
+        case 'create': {
+          const email = args.email
+          const group = args.group
+          if (!email) { result = { error: '--email required' }; break }
+          if (!group) { result = { error: '--group required (group key)' }; break }
+          const body = { email, group_key: group }
+          if (args.name) body.name = args.name
+          if (args['first-name']) body.first_name = args['first-name']
+          if (args['last-name']) body.last_name = args['last-name']
+          result = await api('POST', '/partnerships', body)
+          break
+        }
+        case 'update': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (partnership key)' }; break }
+          const body = {}
+          if (args.name) body.name = args.name
+          if (args.group) body.group_key = args.group
+          result = await api('PATCH', `/partnerships/${key}`, body)
+          break
+        }
+        default:
+          result = { error: 'Unknown partnerships subcommand. Use: list, get, create, update' }
+      }
+      break
+
+    case 'customers':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/customers${buildQuery()}`)
+          break
+        case 'get': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (customer key)' }; break }
+          result = await api('GET', `/customers/${key}`)
+          break
+        }
+        case 'create': {
+          const email = args.email
+          const partnerKey = args['partner-key']
+          if (!email) { result = { error: '--email required' }; break }
+          if (!partnerKey) { result = { error: '--partner-key required' }; break }
+          const body = { email, partner_key: partnerKey }
+          if (args.name) body.name = args.name
+          if (args['customer-key']) body.customer_key = args['customer-key']
+          result = await api('POST', '/customers', body)
+          break
+        }
+        case 'update': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (customer key)' }; break }
+          const body = {}
+          if (args.name) body.name = args.name
+          if (args.email) body.email = args.email
+          if (args['partner-key']) body.partner_key = args['partner-key']
+          result = await api('PATCH', `/customers/${key}`, body)
+          break
+        }
+        case 'delete': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (customer key)' }; break }
+          result = await api('DELETE', `/customers/${key}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown customers subcommand. Use: list, get, create, update, delete' }
+      }
+      break
+
+    case 'transactions':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/transactions${buildQuery()}`)
+          break
+        case 'get': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (transaction key)' }; break }
+          result = await api('GET', `/transactions/${key}`)
+          break
+        }
+        case 'create': {
+          const customerKey = args['customer-key']
+          const amount = args.amount
+          if (!customerKey) { result = { error: '--customer-key required' }; break }
+          if (!amount) { result = { error: '--amount required (in cents)' }; break }
+          const body = {
+            customer_key: customerKey,
+            amount: Number(amount),
+          }
+          if (args.currency) body.currency = args.currency
+          if (args.category) body.category = args.category
+          if (args['product-key']) body.product_key = args['product-key']
+          result = await api('POST', '/transactions', body)
+          break
+        }
+        case 'delete': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (transaction key)' }; break }
+          result = await api('DELETE', `/transactions/${key}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown transactions subcommand. Use: list, get, create, delete' }
+      }
+      break
+
+    case 'deals':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/deals${buildQuery()}`)
+          break
+        case 'get': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (deal key)' }; break }
+          result = await api('GET', `/deals/${key}`)
+          break
+        }
+        case 'create': {
+          const partnerKey = args['partner-key']
+          const name = args.name
+          if (!partnerKey) { result = { error: '--partner-key required' }; break }
+          if (!name) { result = { error: '--name required' }; break }
+          const body = { partner_key: partnerKey, name }
+          if (args.amount) body.amount = Number(args.amount)
+          if (args.currency) body.currency = args.currency
+          if (args.stage) body.stage = args.stage
+          result = await api('POST', '/deals', body)
+          break
+        }
+        case 'update': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (deal key)' }; break }
+          const body = {}
+          if (args.name) body.name = args.name
+          if (args.amount) body.amount = Number(args.amount)
+          if (args.stage) body.stage = args.stage
+          if (args.status) body.status = args.status
+          result = await api('PATCH', `/deals/${key}`, body)
+          break
+        }
+        case 'archive': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (deal key)' }; break }
+          result = await api('DELETE', `/deals/${key}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown deals subcommand. Use: list, get, create, update, archive' }
+      }
+      break
+
+    case 'actions':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/actions${buildQuery()}`)
+          break
+        case 'create': {
+          const customerKey = args['customer-key']
+          const actionKey = args['action-key']
+          if (!customerKey) { result = { error: '--customer-key required' }; break }
+          if (!actionKey) { result = { error: '--action-key required' }; break }
+          const body = {
+            customer_key: customerKey,
+            key: actionKey,
+          }
+          if (args.value) body.value = Number(args.value)
+          result = await api('POST', '/actions', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown actions subcommand. Use: list, create' }
+      }
+      break
+
+    case 'rewards':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/rewards${buildQuery()}`)
+          break
+        case 'create': {
+          const partnerKey = args['partner-key']
+          const amount = args.amount
+          if (!partnerKey) { result = { error: '--partner-key required' }; break }
+          if (!amount) { result = { error: '--amount required (in cents)' }; break }
+          const body = {
+            partner_key: partnerKey,
+            amount: Number(amount),
+          }
+          if (args.description) body.description = args.description
+          if (args.currency) body.currency = args.currency
+          result = await api('POST', '/rewards', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown rewards subcommand. Use: list, create' }
+      }
+      break
+
+    case 'leads':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/leads${buildQuery()}`)
+          break
+        case 'get': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (lead key)' }; break }
+          result = await api('GET', `/leads/${key}`)
+          break
+        }
+        case 'create': {
+          const partnerKey = args['partner-key']
+          const email = args.email
+          if (!partnerKey) { result = { error: '--partner-key required' }; break }
+          if (!email) { result = { error: '--email required' }; break }
+          const body = { partner_key: partnerKey, email }
+          if (args.name) body.name = args.name
+          if (args.company) body.company = args.company
+          result = await api('POST', '/leads', body)
+          break
+        }
+        case 'update': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (lead key)' }; break }
+          const body = {}
+          if (args.email) body.email = args.email
+          if (args.name) body.name = args.name
+          if (args.status) body.status = args.status
+          result = await api('PATCH', `/leads/${key}`, body)
+          break
+        }
+        default:
+          result = { error: 'Unknown leads subcommand. Use: list, get, create, update' }
+      }
+      break
+
+    case 'groups':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/groups${buildQuery()}`)
+          break
+        default:
+          result = { error: 'Unknown groups subcommand. Use: list' }
+      }
+      break
+
+    case 'webhooks':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/webhooks${buildQuery()}`)
+          break
+        case 'get': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (webhook key)' }; break }
+          result = await api('GET', `/webhooks/${key}`)
+          break
+        }
+        case 'create': {
+          const target = args.target
+          if (!target) { result = { error: '--target required (webhook URL)' }; break }
+          const body = { target }
+          if (args.events) body.events = args.events.split(',')
+          result = await api('POST', '/webhooks', body)
+          break
+        }
+        case 'delete': {
+          const key = args.key
+          if (!key) { result = { error: '--key required (webhook key)' }; break }
+          result = await api('DELETE', `/webhooks/${key}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown webhooks subcommand. Use: list, get, create, delete' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          partnerships: 'partnerships [list | get --key <key> | create --email <email> --group <group-key> | update --key <key>]',
+          customers: 'customers [list | get --key <key> | create --email <email> --partner-key <key> | update --key <key> | delete --key <key>]',
+          transactions: 'transactions [list | get --key <key> | create --customer-key <key> --amount <cents> | delete --key <key>]',
+          deals: 'deals [list | get --key <key> | create --partner-key <key> --name <name> | update --key <key> | archive --key <key>]',
+          actions: 'actions [list | create --customer-key <key> --action-key <key> [--value <n>]]',
+          rewards: 'rewards [list | create --partner-key <key> --amount <cents>]',
+          leads: 'leads [list | get --key <key> | create --partner-key <key> --email <email> | update --key <key>]',
+          groups: 'groups [list]',
+          webhooks: 'webhooks [list | get --key <key> | create --target <url> [--events <evt1,evt2>] | delete --key <key>]',
+          options: '--limit <n> --after <cursor> --before <cursor> --order-by <field>',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})

package/payload/tools/clis/plausible.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+const API_KEY = process.env.PLAUSIBLE_API_KEY
+const BASE_URL = process.env.PLAUSIBLE_BASE_URL || 'https://plausible.io'
+
+if (!API_KEY) {
+  console.error(JSON.stringify({ error: 'PLAUSIBLE_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', 'Accept': 'application/json' }, body: body || undefined }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    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
+  const siteId = args['site-id']
+  const dateRange = args['date-range'] || '30d'
+  const limit = args.limit ? Number(args.limit) : 100
+
+  switch (cmd) {
+    case 'stats':
+      if (!siteId) { result = { error: '--site-id required (your domain, e.g. example.com)' }; break }
+      switch (sub) {
+        case 'aggregate': {
+          const metrics = args.metrics?.split(',') || ['visitors', 'pageviews', 'bounce_rate', 'visit_duration']
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+          })
+          break
+        }
+        case 'timeseries': {
+          const metrics = args.metrics?.split(',') || ['visitors', 'pageviews']
+          const period = args.period || 'time:day'
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+            dimensions: [period],
+          })
+          break
+        }
+        case 'pages': {
+          const metrics = args.metrics?.split(',') || ['visitors', 'pageviews']
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+            dimensions: ['event:page'],
+            pagination: { limit },
+          })
+          break
+        }
+        case 'sources': {
+          const metrics = args.metrics?.split(',') || ['visitors', 'bounce_rate']
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+            dimensions: ['visit:source'],
+            pagination: { limit },
+          })
+          break
+        }
+        case 'countries': {
+          const metrics = args.metrics?.split(',') || ['visitors', 'percentage']
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+            dimensions: ['visit:country'],
+            pagination: { limit },
+          })
+          break
+        }
+        case 'devices': {
+          const metrics = args.metrics?.split(',') || ['visitors', 'percentage']
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+            dimensions: ['visit:device'],
+            pagination: { limit },
+          })
+          break
+        }
+        case 'utm': {
+          const param = args.param || 'utm_source'
+          const metrics = args.metrics?.split(',') || ['visitors', 'bounce_rate']
+          result = await api('POST', '/api/v2/query', {
+            site_id: siteId,
+            metrics,
+            date_range: dateRange,
+            dimensions: [`visit:${param}`],
+            pagination: { limit },
+          })
+          break
+        }
+        case 'query': {
+          const metrics = args.metrics?.split(',')
+          if (!metrics) { result = { error: '--metrics required (comma-separated)' }; break }
+          const body = { site_id: siteId, metrics, date_range: dateRange }
+          if (args.dimensions) body.dimensions = args.dimensions.split(',')
+          if (args.filters) {
+            try { body.filters = JSON.parse(args.filters) } catch { result = { error: '--filters must be valid JSON' }; break }
+          }
+          body.pagination = { limit }
+          result = await api('POST', '/api/v2/query', body)
+          break
+        }
+        case 'realtime':
+          result = await api('GET', `/api/v1/stats/realtime/visitors?site_id=${encodeURIComponent(siteId)}`)
+          break
+        default:
+          result = { error: 'Unknown stats subcommand. Use: aggregate, timeseries, pages, sources, countries, devices, utm, query, realtime' }
+      }
+      break
+
+    case 'sites':
+      switch (sub) {
+        case 'list':
+          result = await api('GET', '/api/v1/sites')
+          break
+        case 'get': {
+          if (!siteId) { result = { error: '--site-id required' }; break }
+          result = await api('GET', `/api/v1/sites/${encodeURIComponent(siteId)}`)
+          break
+        }
+        case 'create': {
+          const domain = args.domain
+          if (!domain) { result = { error: '--domain required' }; break }
+          const body = { domain }
+          if (args.timezone) body.timezone = args.timezone
+          result = await api('POST', '/api/v1/sites', body)
+          break
+        }
+        case 'delete': {
+          if (!siteId) { result = { error: '--site-id required' }; break }
+          result = await api('DELETE', `/api/v1/sites/${encodeURIComponent(siteId)}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown sites subcommand. Use: list, get, create, delete' }
+      }
+      break
+
+    case 'goals':
+      if (!siteId) { result = { error: '--site-id required' }; break }
+      switch (sub) {
+        case 'list':
+          result = await api('GET', `/api/v1/sites/goals?site_id=${encodeURIComponent(siteId)}`)
+          break
+        case 'create': {
+          const goalType = args['goal-type']
+          if (!goalType) { result = { error: '--goal-type required (event or page)' }; break }
+          const body = { site_id: siteId, goal_type: goalType }
+          if (goalType === 'event') {
+            if (!args['event-name']) { result = { error: '--event-name required for event goals' }; break }
+            body.event_name = args['event-name']
+          } else if (goalType === 'page') {
+            if (!args['page-path']) { result = { error: '--page-path required for page goals' }; break }
+            body.page_path = args['page-path']
+          }
+          result = await api('PUT', '/api/v1/sites/goals', body)
+          break
+        }
+        case 'delete': {
+          const goalId = args['goal-id']
+          if (!goalId) { result = { error: '--goal-id required' }; break }
+          result = await api('DELETE', `/api/v1/sites/goals/${goalId}`, { site_id: siteId })
+          break
+        }
+        default:
+          result = { error: 'Unknown goals subcommand. Use: list, create, delete' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          stats: {
+            aggregate: 'stats aggregate --site-id <domain> [--date-range <30d>] [--metrics <m1,m2>]',
+            timeseries: 'stats timeseries --site-id <domain> [--date-range <30d>] [--period <time:day>]',
+            pages: 'stats pages --site-id <domain> [--date-range <30d>] [--limit <n>]',
+            sources: 'stats sources --site-id <domain> [--date-range <30d>]',
+            countries: 'stats countries --site-id <domain> [--date-range <30d>]',
+            devices: 'stats devices --site-id <domain> [--date-range <30d>]',
+            utm: 'stats utm --site-id <domain> [--param <utm_source>] [--date-range <30d>]',
+            query: 'stats query --site-id <domain> --metrics <m1,m2> [--dimensions <d1,d2>] [--filters <json>]',
+            realtime: 'stats realtime --site-id <domain>',
+          },
+          sites: 'sites [list | get --site-id <domain> | create --domain <domain> | delete --site-id <domain>]',
+          goals: 'goals [list | create --goal-type <event|page> --event-name <name> | delete --goal-id <id>] --site-id <domain>',
+          options: '--date-range <day|7d|30d|month|6mo|12mo|year> --limit <n>',
+          env: 'PLAUSIBLE_BASE_URL for self-hosted instances (default: https://plausible.io)',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})