@miranda0808/maya-codex 0.1.0

package/payload/tools/clis/mixpanel.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+const TOKEN = process.env.MIXPANEL_TOKEN
+const API_KEY = process.env.MIXPANEL_API_KEY
+const SECRET = process.env.MIXPANEL_SECRET
+const INGESTION_URL = 'https://api.mixpanel.com'
+const QUERY_URL = 'https://mixpanel.com/api/2.0'
+const EXPORT_URL = 'https://data.mixpanel.com/api/2.0'
+
+if (!TOKEN && !API_KEY) {
+  console.error(JSON.stringify({ error: 'MIXPANEL_TOKEN (for ingestion) or MIXPANEL_API_KEY + MIXPANEL_SECRET (for query/export) environment variables required' }))
+  process.exit(1)
+}
+
+async function ingestApi(method, path, body) {
+  const headers = { 'Content-Type': 'application/json' }
+  if (args['dry-run']) {
+    const maskedBody = body ? JSON.parse(JSON.stringify(body)) : undefined
+    if (Array.isArray(maskedBody)) maskedBody.forEach(item => {
+      if (item.properties && item.properties.token) item.properties.token = '***'
+      if (item.$token) item.$token = '***'
+    })
+    return { _dry_run: true, method, url: `${INGESTION_URL}${path}`, headers, body: maskedBody }
+  }
+  const res = await fetch(`${INGESTION_URL}${path}`, {
+    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 }
+  }
+}
+
+async function queryApi(method, baseUrl, path, params) {
+  if (!API_KEY || !SECRET) {
+    return { error: 'MIXPANEL_API_KEY and MIXPANEL_SECRET required for query/export operations' }
+  }
+  const auth = Buffer.from(`${API_KEY}:${SECRET}`).toString('base64')
+  const url = params ? `${baseUrl}${path}?${params}` : `${baseUrl}${path}`
+  const headers = {
+    'Authorization': `Basic ${auth}`,
+    'Content-Type': 'application/json',
+  }
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url, headers: { ...headers, Authorization: '***' } }
+  }
+  const res = await fetch(url, {
+    method,
+    headers,
+  })
+  const text = await res.text()
+  try {
+    return JSON.parse(text)
+  } catch {
+    return { status: res.status, body: text }
+  }
+}
+
+async function queryApiPost(path, body) {
+  if (!API_KEY || !SECRET) {
+    return { error: 'MIXPANEL_API_KEY and MIXPANEL_SECRET required for query/export operations' }
+  }
+  const auth = Buffer.from(`${API_KEY}:${SECRET}`).toString('base64')
+  const headers = {
+    'Authorization': `Basic ${auth}`,
+    'Content-Type': 'application/json',
+  }
+  if (args['dry-run']) {
+    return { _dry_run: true, method: 'POST', url: `${QUERY_URL}${path}`, headers: { ...headers, Authorization: '***' }, body: body || undefined }
+  }
+  const res = await fetch(`${QUERY_URL}${path}`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  })
+  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 'track':
+      switch (sub) {
+        case 'event': {
+          if (!TOKEN) { result = { error: 'MIXPANEL_TOKEN required for tracking' }; break }
+          if (!args['distinct-id']) { result = { error: '--distinct-id required' }; break }
+          if (!args.event) { result = { error: '--event required' }; break }
+          let properties
+          try { properties = args.properties ? JSON.parse(args.properties) : {} } catch { result = { error: 'Invalid JSON in --properties' }; break }
+          properties.token = TOKEN
+          properties.distinct_id = args['distinct-id']
+          result = await ingestApi('POST', '/track', [{
+            event: args.event,
+            properties,
+          }])
+          break
+        }
+        default:
+          result = { error: 'Unknown track subcommand. Use: event' }
+      }
+      break
+
+    case 'profiles':
+      switch (sub) {
+        case 'set': {
+          if (!TOKEN) { result = { error: 'MIXPANEL_TOKEN required for profiles' }; break }
+          if (!args['distinct-id']) { result = { error: '--distinct-id required' }; break }
+          let properties
+          try { properties = args.properties ? JSON.parse(args.properties) : {} } catch { result = { error: 'Invalid JSON in --properties' }; break }
+          result = await ingestApi('POST', '/engage', [{
+            $token: TOKEN,
+            $distinct_id: args['distinct-id'],
+            $set: properties,
+          }])
+          break
+        }
+        default:
+          result = { error: 'Unknown profiles subcommand. Use: set' }
+      }
+      break
+
+    case 'query':
+      switch (sub) {
+        case 'events': {
+          if (!args['project-id']) { result = { error: '--project-id required' }; break }
+          const body = {
+            project_id: parseInt(args['project-id']),
+            bookmark_id: null,
+            params: {
+              events: [{ event: args.event || 'all' }],
+              time_range: {
+                from_date: args['from-date'] || new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10),
+                to_date: args['to-date'] || new Date().toISOString().slice(0, 10),
+              },
+            },
+          }
+          result = await queryApiPost('/insights', body)
+          break
+        }
+        default:
+          result = { error: 'Unknown query subcommand. Use: events' }
+      }
+      break
+
+    case 'funnels':
+      switch (sub) {
+        case 'get': {
+          if (!args['funnel-id']) { result = { error: '--funnel-id required' }; break }
+          const params = new URLSearchParams()
+          params.set('funnel_id', args['funnel-id'])
+          if (args['from-date']) params.set('from_date', args['from-date'])
+          if (args['to-date']) params.set('to_date', args['to-date'])
+          result = await queryApi('GET', QUERY_URL, '/funnels', params)
+          break
+        }
+        default:
+          result = { error: 'Unknown funnels subcommand. Use: get' }
+      }
+      break
+
+    case 'retention':
+      switch (sub) {
+        case 'get': {
+          if (!args['from-date'] || !args['to-date']) { result = { error: '--from-date and --to-date required (YYYY-MM-DD)' }; break }
+          const params = new URLSearchParams()
+          params.set('from_date', args['from-date'])
+          params.set('to_date', args['to-date'])
+          params.set('retention_type', 'birth')
+          if (args['born-event']) params.set('born_event', args['born-event'])
+          result = await queryApi('GET', QUERY_URL, '/retention', params)
+          break
+        }
+        default:
+          result = { error: 'Unknown retention subcommand. Use: get' }
+      }
+      break
+
+    case 'export':
+      switch (sub) {
+        case 'events': {
+          if (!args['from-date']) { result = { error: '--from-date required' }; break }
+          if (!args['to-date']) { result = { error: '--to-date required' }; break }
+          const params = new URLSearchParams()
+          params.set('from_date', args['from-date'])
+          params.set('to_date', args['to-date'])
+          if (args.event) params.set('event', JSON.stringify([args.event]))
+          result = await queryApi('GET', EXPORT_URL, '/export', params)
+          break
+        }
+        default:
+          result = { error: 'Unknown export subcommand. Use: events' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          track: 'track event --distinct-id <id> --event <name> [--properties <json>]',
+          profiles: 'profiles set --distinct-id <id> [--properties <json>]',
+          query: 'query events --project-id <id> [--event <name>] [--from-date <date>] [--to-date <date>]',
+          funnels: 'funnels get --funnel-id <id> [--from-date <date>] [--to-date <date>]',
+          retention: 'retention get [--from-date <date>] [--to-date <date>] [--born-event <event>]',
+          export: 'export events --from-date <date> --to-date <date>',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})

package/payload/tools/clis/onesignal.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+const REST_API_KEY = process.env.ONESIGNAL_REST_API_KEY
+const APP_ID = process.env.ONESIGNAL_APP_ID
+const BASE_URL = 'https://api.onesignal.com'
+
+if (!REST_API_KEY) {
+  console.error(JSON.stringify({ error: 'ONESIGNAL_REST_API_KEY environment variable required' }))
+  process.exit(1)
+}
+
+if (!APP_ID) {
+  console.error(JSON.stringify({ error: 'ONESIGNAL_APP_ID environment variable required' }))
+  process.exit(1)
+}
+
+async function api(method, path, body) {
+  const headers = {
+    'Authorization': `Basic ${REST_API_KEY}`,
+    'Content-Type': 'application/json',
+    'Accept': 'application/json',
+  }
+  if (args['dry-run']) {
+    return { _dry_run: true, method, url: `${BASE_URL}${path}`, headers: { ...headers, Authorization: '***' }, body: body || undefined }
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    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
+  const limit = args.limit ? Number(args.limit) : 50
+  const offset = args.offset ? Number(args.offset) : 0
+
+  switch (cmd) {
+    case 'notifications':
+      switch (sub) {
+        case 'send': {
+          const message = args.message
+          if (!message) { result = { error: '--message required' }; break }
+          const payload = {
+            app_id: APP_ID,
+            contents: { en: message },
+          }
+          if (args.heading) payload.headings = { en: args.heading }
+          if (args.url) payload.url = args.url
+          if (args.data) {
+            try { payload.data = JSON.parse(args.data) } catch { payload.data = { value: args.data } }
+          }
+          if (args.segment) {
+            payload.included_segments = args.segment.split(',')
+          } else if (args.emails) {
+            payload.include_email_tokens = args.emails.split(',')
+          } else if (args['player-ids']) {
+            payload.include_player_ids = args['player-ids'].split(',')
+          } else if (args.aliases) {
+            try {
+              payload.include_aliases = JSON.parse(args.aliases)
+            } catch {
+              payload.include_aliases = { external_id: args.aliases.split(',') }
+            }
+            payload.target_channel = args.channel || 'push'
+          } else {
+            payload.included_segments = ['Subscribed Users']
+          }
+          if (args['send-after']) payload.send_after = args['send-after']
+          if (args.ttl) payload.ttl = Number(args.ttl)
+          result = await api('POST', '/api/v1/notifications', payload)
+          break
+        }
+        case 'list': {
+          result = await api('GET', `/api/v1/notifications?app_id=${APP_ID}&limit=${limit}&offset=${offset}`)
+          break
+        }
+        case 'get': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('GET', `/api/v1/notifications/${id}?app_id=${APP_ID}`)
+          break
+        }
+        case 'cancel': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('DELETE', `/api/v1/notifications/${id}?app_id=${APP_ID}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown notifications subcommand. Use: send, list, get, cancel' }
+      }
+      break
+
+    case 'segments':
+      switch (sub) {
+        case 'list': {
+          result = await api('GET', `/api/v1/apps/${APP_ID}/segments?offset=${offset}&limit=${limit}`)
+          break
+        }
+        case 'create': {
+          const name = args.name
+          if (!name) { result = { error: '--name required' }; break }
+          let filters
+          try { filters = args.filters ? JSON.parse(args.filters) : [{ field: 'session_count', relation: '>', value: '0' }] } catch { result = { error: 'Invalid JSON in --filters' }; break }
+          result = await api('POST', `/api/v1/apps/${APP_ID}/segments`, { name, filters })
+          break
+        }
+        case 'delete': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('DELETE', `/api/v1/apps/${APP_ID}/segments/${id}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown segments subcommand. Use: list, create, delete' }
+      }
+      break
+
+    case 'users':
+      switch (sub) {
+        case 'get': {
+          const aliasLabel = args['alias-label'] || 'external_id'
+          const aliasId = args['alias-id']
+          if (!aliasId) { result = { error: '--alias-id required' }; break }
+          result = await api('GET', `/api/v1/apps/${APP_ID}/users/by/${aliasLabel}/${aliasId}`)
+          break
+        }
+        case 'create': {
+          const payload = {}
+          if (args['external-id']) {
+            payload.identity = { external_id: args['external-id'] }
+          }
+          if (args.email) {
+            payload.subscriptions = [{ type: 'Email', token: args.email }]
+          }
+          if (args.tags) {
+            try { payload.tags = JSON.parse(args.tags) } catch { result = { error: 'Invalid --tags JSON' }; break }
+          }
+          result = await api('POST', `/api/v1/apps/${APP_ID}/users`, payload)
+          break
+        }
+        case 'delete': {
+          const aliasLabel = args['alias-label'] || 'external_id'
+          const aliasId = args['alias-id']
+          if (!aliasId) { result = { error: '--alias-id required' }; break }
+          result = await api('DELETE', `/api/v1/apps/${APP_ID}/users/by/${aliasLabel}/${aliasId}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown users subcommand. Use: get, create, delete' }
+      }
+      break
+
+    case 'templates':
+      switch (sub) {
+        case 'list': {
+          result = await api('GET', `/api/v1/templates?app_id=${APP_ID}&limit=${limit}&offset=${offset}`)
+          break
+        }
+        case 'get': {
+          const id = args.id
+          if (!id) { result = { error: '--id required' }; break }
+          result = await api('GET', `/api/v1/templates/${id}?app_id=${APP_ID}`)
+          break
+        }
+        case 'create': {
+          const name = args.name
+          if (!name) { result = { error: '--name required' }; break }
+          const payload = { app_id: APP_ID, name }
+          if (args.message) payload.contents = { en: args.message }
+          if (args.heading) payload.headings = { en: args.heading }
+          result = await api('POST', '/api/v1/templates', payload)
+          break
+        }
+        default:
+          result = { error: 'Unknown templates subcommand. Use: list, get, create' }
+      }
+      break
+
+    case 'app':
+      switch (sub) {
+        case 'get': {
+          result = await api('GET', `/api/v1/apps/${APP_ID}`)
+          break
+        }
+        default:
+          result = { error: 'Unknown app subcommand. Use: get' }
+      }
+      break
+
+    default:
+      result = {
+        error: 'Unknown command',
+        usage: {
+          notifications: 'notifications [send --message <msg> --segment <s> | list | get --id <id> | cancel --id <id>]',
+          segments: 'segments [list | create --name <n> --filters <json> | delete --id <id>]',
+          users: 'users [get --alias-id <id> | create --external-id <id> --email <e> | delete --alias-id <id>]',
+          templates: 'templates [list | get --id <id> | create --name <n> --message <msg>]',
+          app: 'app [get]',
+          options: '--limit <n> --offset <n>',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(1)
+})