@gelglx/arjunakey 1.0.0

package/README.md

@@ -0,0 +1,66 @@
+# arjuna-key-cli
+
+CLI satu akun untuk:
+
+1. membuat informasi akun acak,
+2. register ke `https://dash.arjuna.dev/register`,
+3. login,
+4. klaim kode welcome/voucher,
+5. mengambil API key dari `/api/me`.
+
+Tidak ada dependency npm eksternal.
+
+## Instalasi lokal
+
+```bash
+cd /home/ubuntu/arjuna-key-cli
+npm install -g .
+```
+
+## Pemakaian
+
+```bash
+arjunakey create
+```
+
+Kode default:
+
+```text
+ONE-GROUP-6T2E-2V7N-H37Q
+```
+
+Kode tersebut adalah welcome-group code. Website memprosesnya melalui `/api/billing/signup-bonus`, bukan form voucher billing biasa. CLI mencoba welcome endpoint lebih dulu lalu fallback ke `/api/billing/redeem` untuk voucher biasa.
+
+Output hanya API key:
+
+```bash
+arjunakey create --raw
+```
+
+Simpan key sebagai teks polos, satu key per baris:
+
+```bash
+arjunakey create --raw --save ./api-keys.txt
+```
+
+Simpan data akun lengkap sebagai JSON Lines:
+
+```bash
+arjunakey create --account-out ./accounts.jsonl
+```
+
+Gunakan akun yang sudah ada:
+
+```bash
+ARJUNA_EMAIL='user@example.com' \
+ARJUNA_PASSWORD='password' \
+arjunakey login --no-claim --raw
+```
+
+Lihat semua opsi:
+
+```bash
+arjunakey --help
+```
+
+CLI sengaja hanya memproses satu akun per eksekusi; tidak menyediakan farm, worker paralel, proxy rotation, atau batch account creation.

package/cli.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const { URL } = require('url');
+
+const VERSION = '1.0.0';
+const DEFAULT_BASE_URL = 'https://dash.arjuna.dev';
+const DEFAULT_CODE = 'ONE-GROUP-6T2E-2V7N-H37Q';
+
+class ApiError extends Error {
+  constructor(message, response = null) {
+    super(message);
+    this.name = 'ApiError';
+    this.response = response;
+  }
+}
+
+class Client {
+  constructor(baseUrl, timeoutMs) {
+    this.baseUrl = new URL(baseUrl);
+    this.timeoutMs = timeoutMs;
+    this.cookies = new Map();
+  }
+
+  cookieHeader() {
+    return [...this.cookies.entries()].map(([name, value]) => `${name}=${value}`).join('; ');
+  }
+
+  captureCookies(headers) {
+    const values = headers['set-cookie'];
+    if (!values) return;
+    for (const line of Array.isArray(values) ? values : [values]) {
+      const pair = line.split(';', 1)[0];
+      const equals = pair.indexOf('=');
+      if (equals > 0) this.cookies.set(pair.slice(0, equals).trim(), pair.slice(equals + 1).trim());
+    }
+  }
+
+  request(method, pathname, body = undefined) {
+    const target = new URL(pathname, this.baseUrl);
+    const payload = body === undefined ? null : JSON.stringify(body);
+    const headers = {
+      Accept: 'application/json',
+      Origin: this.baseUrl.origin,
+      Referer: `${this.baseUrl.origin}/`,
+      'User-Agent': `arjuna-key-cli/${VERSION}`,
+    };
+    if (payload !== null) {
+      headers['Content-Type'] = 'application/json';
+      headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+    const cookie = this.cookieHeader();
+    if (cookie) headers.Cookie = cookie;
+
+    return new Promise((resolve, reject) => {
+      const transport = target.protocol === 'https:' ? https : http;
+      const req = transport.request({
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port || undefined,
+        path: target.pathname + target.search,
+        method,
+        headers,
+        timeout: this.timeoutMs,
+      }, res => {
+        this.captureCookies(res.headers);
+        const chunks = [];
+        res.on('data', chunk => chunks.push(chunk));
+        res.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf8');
+          let data = null;
+          try { data = text ? JSON.parse(text) : {}; }
+          catch { data = { raw: text }; }
+          resolve({ status: res.statusCode || 0, headers: res.headers, data, text });
+        });
+      });
+      req.on('timeout', () => req.destroy(new Error(`Request timeout after ${this.timeoutMs} ms`)));
+      req.on('error', reject);
+      if (payload !== null) req.write(payload);
+      req.end();
+    });
+  }
+}
+
+function apiMessage(response, fallback) {
+  return response?.data?.error || response?.data?.message || fallback;
+}
+
+function assertOk(response, fallback) {
+  if (response.status < 200 || response.status >= 300) {
+    throw new ApiError(apiMessage(response, `${fallback} (HTTP ${response.status})`), response);
+  }
+  return response.data;
+}
+
+const FIRST_NAMES = ['Adit', 'Bagas', 'Bima', 'Dian', 'Fajar', 'Galih', 'Intan', 'Nadia', 'Raka', 'Rizky', 'Salsa', 'Tegar'];
+const LAST_NAMES = ['Kusuma', 'Maulana', 'Nugroho', 'Pratama', 'Ramadhan', 'Saputra', 'Setiawan', 'Utami', 'Wijaya', 'Wulandari'];
+
+function randomItem(items) {
+  return items[crypto.randomInt(items.length)];
+}
+
+function randomProfile(emailDomain) {
+  const first = randomItem(FIRST_NAMES);
+  const last = randomItem(LAST_NAMES);
+  const suffix = crypto.randomBytes(6).toString('hex');
+  return {
+    name: `${first} ${last}`,
+    email: `${first}.${last}.${suffix}@${emailDomain}`.toLowerCase(),
+    password: `A!7a${crypto.randomBytes(15).toString('base64url')}`,
+  };
+}
+
+function validateProfile(profile) {
+  if (profile.name.length < 2 || profile.name.length > 80) throw new Error('Nama harus 2-80 karakter.');
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(profile.email) || profile.email.length > 254) throw new Error('Alamat email tidak valid.');
+  if (profile.password.length < 8 || profile.password.length > 128) throw new Error('Password harus 8-128 karakter.');
+}
+
+async function login(client, email, password) {
+  const response = await client.request('POST', '/api/auth/login', { email, password });
+  assertOk(response, 'Gagal masuk');
+  if (!client.cookies.size) throw new Error('Server tidak mengirim cookie sesi setelah login.');
+}
+
+async function register(client, profile) {
+  const response = await client.request('POST', '/api/auth/register', {
+    name: profile.name,
+    email: profile.email,
+    password: profile.password,
+    website: '',
+  });
+  assertOk(response, 'Gagal membuat akun');
+}
+
+async function claimCode(client, code) {
+  const groupResponse = await client.request('POST', '/api/billing/signup-bonus', { code });
+  if (groupResponse.status >= 200 && groupResponse.status < 300) {
+    return { kind: 'welcome-group', ...groupResponse.data };
+  }
+
+  if (![400, 404].includes(groupResponse.status)) {
+    throw new ApiError(apiMessage(groupResponse, 'Gagal klaim welcome code'), groupResponse);
+  }
+
+  const voucherResponse = await client.request('POST', '/api/billing/redeem', { code });
+  if (voucherResponse.status >= 200 && voucherResponse.status < 300) {
+    return { kind: 'voucher', ...voucherResponse.data };
+  }
+
+  const groupError = apiMessage(groupResponse, 'Welcome code ditolak');
+  const voucherError = apiMessage(voucherResponse, 'Voucher ditolak');
+  throw new ApiError(`${groupError}; ${voucherError}`, voucherResponse);
+}
+
+async function getAccount(client) {
+  const response = await client.request('GET', '/api/me');
+  const account = assertOk(response, 'Gagal mengambil informasi akun');
+  if (!account.apiKey || typeof account.apiKey !== 'string') throw new Error('API key tidak ditemukan pada respons /api/me.');
+  return account;
+}
+
+function parseArgs(argv) {
+  const opts = {
+    command: 'create',
+    baseUrl: process.env.ARJUNA_BASE_URL || DEFAULT_BASE_URL,
+    voucher: process.env.ARJUNA_VOUCHER || DEFAULT_CODE,
+    emailDomain: process.env.ARJUNA_EMAIL_DOMAIN || 'example.com',
+    timeout: Number(process.env.ARJUNA_TIMEOUT || 30),
+    json: false,
+    raw: false,
+    noClaim: false,
+    quiet: false,
+  };
+
+  const input = [...argv];
+  if (input[0] && !input[0].startsWith('-')) opts.command = input.shift();
+  const valueFlags = new Set(['--base-url', '--voucher', '--email-domain', '--name', '--email', '--password', '--save', '--account-out', '--timeout']);
+
+  for (let i = 0; i < input.length; i++) {
+    let flag = input[i];
+    let inlineValue;
+    if (flag.startsWith('--') && flag.includes('=')) {
+      const at = flag.indexOf('=');
+      inlineValue = flag.slice(at + 1);
+      flag = flag.slice(0, at);
+    }
+    let value;
+    if (valueFlags.has(flag)) {
+      value = inlineValue !== undefined ? inlineValue : input[++i];
+      if (value === undefined) throw new Error(`${flag} membutuhkan nilai.`);
+    } else if (inlineValue !== undefined) {
+      throw new Error(`Flag ${flag} tidak menerima nilai.`);
+    }
+
+    switch (flag) {
+      case '--base-url': opts.baseUrl = value; break;
+      case '--voucher': opts.voucher = value; break;
+      case '--email-domain': opts.emailDomain = value; break;
+      case '--name': opts.name = value; break;
+      case '--email': opts.email = value; break;
+      case '--password': opts.password = value; break;
+      case '--save': opts.save = value; break;
+      case '--account-out': opts.accountOut = value; break;
+      case '--timeout': opts.timeout = Number(value); break;
+      case '--json': opts.json = true; break;
+      case '--raw': opts.raw = true; break;
+      case '--no-claim': opts.noClaim = true; break;
+      case '--quiet': opts.quiet = true; break;
+      case '-h': case '--help': opts.command = 'help'; break;
+      case '-v': case '--version': opts.command = 'version'; break;
+      default: throw new Error(`Flag tidak dikenal: ${flag}`);
+    }
+  }
+  return opts;
+}
+
+function validateOptions(opts) {
+  if (!['create', 'login', 'help', 'version'].includes(opts.command)) throw new Error(`Perintah tidak dikenal: ${opts.command}`);
+  const base = new URL(opts.baseUrl);
+  if (!['http:', 'https:'].includes(base.protocol)) throw new Error('Base URL harus memakai http atau https.');
+  opts.baseUrl = base.origin;
+  if (!Number.isFinite(opts.timeout) || opts.timeout < 1 || opts.timeout > 300) throw new Error('Timeout harus 1-300 detik.');
+  if (opts.raw && opts.json) throw new Error('Pilih salah satu: --raw atau --json.');
+  if (opts.command === 'login' && !(opts.email || process.env.ARJUNA_EMAIL)) throw new Error('login membutuhkan --email atau ARJUNA_EMAIL.');
+  if (opts.command === 'login' && !(opts.password || process.env.ARJUNA_PASSWORD)) throw new Error('login membutuhkan --password atau ARJUNA_PASSWORD.');
+}
+
+function secureAppend(file, line) {
+  const resolved = path.resolve(file);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  const fd = fs.openSync(resolved, 'a', 0o600);
+  try { fs.writeSync(fd, `${line}\n`); }
+  finally { fs.closeSync(fd); }
+  try { fs.chmodSync(resolved, 0o600); } catch {}
+  return resolved;
+}
+
+function printResult(result, opts) {
+  if (opts.raw) {
+    process.stdout.write(`${result.apiKey}\n`);
+    return;
+  }
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  console.log(`name=${result.name}`);
+  console.log(`email=${result.email}`);
+  if (result.password) console.log(`password=${result.password}`);
+  if (result.claim) {
+    console.log(`claim_type=${result.claim.kind}`);
+    console.log(`claim_tokens=${result.claim.tokenAmount ?? ''}`);
+  }
+  console.log(`balance=${result.balance}`);
+  console.log(`status=${result.status}`);
+  console.log(`base_url=${result.baseUrl}`);
+  console.log(`api_key=${result.apiKey}`);
+  if (result.savedKeyFile) console.log(`key_file=${result.savedKeyFile}`);
+  if (result.savedAccountFile) console.log(`account_file=${result.savedAccountFile}`);
+}
+
+function help() {
+  console.log(`arjunakey ${VERSION}
+
+Pemakaian:
+  arjunakey create [opsi]
+  arjunakey login --email EMAIL --password PASSWORD [opsi]
+
+create membuat satu akun acak, login, klaim kode, lalu mengambil API key.
+Kode default: ${DEFAULT_CODE}
+
+Opsi:
+  --voucher CODE       Welcome/voucher code
+  --email-domain HOST  Domain email acak (default: example.com)
+  --name NAME          Ganti nama acak
+  --email EMAIL        Ganti email acak
+  --password PASS      Ganti password acak
+  --no-claim           Lewati klaim kode
+  --save FILE          Tambahkan API key ke FILE (satu key per baris)
+  --account-out FILE   Tambahkan data akun JSON ke FILE
+  --raw                 Hanya cetak API key
+  --json                Cetak hasil JSON
+  --base-url URL        Dashboard URL (default: ${DEFAULT_BASE_URL})
+  --timeout SEC         Timeout request (default: 30)
+  -h, --help            Bantuan
+  -v, --version         Versi
+
+Environment:
+  ARJUNA_EMAIL, ARJUNA_PASSWORD, ARJUNA_BASE_URL,
+  ARJUNA_VOUCHER, ARJUNA_EMAIL_DOMAIN, ARJUNA_TIMEOUT`);
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  validateOptions(opts);
+  if (opts.command === 'help') return help();
+  if (opts.command === 'version') return console.log(VERSION);
+
+  const client = new Client(opts.baseUrl, opts.timeout * 1000);
+  let profile;
+  let claim = null;
+
+  if (opts.command === 'create') {
+    profile = randomProfile(opts.emailDomain);
+    if (opts.name) profile.name = opts.name;
+    if (opts.email) profile.email = opts.email.toLowerCase();
+    if (opts.password) profile.password = opts.password;
+    validateProfile(profile);
+    if (!opts.quiet && !opts.raw && !opts.json) console.error('Membuat akun...');
+    await register(client, profile);
+    if (!opts.quiet && !opts.raw && !opts.json) console.error('Masuk ke akun...');
+    await login(client, profile.email, profile.password);
+  } else {
+    profile = {
+      email: (opts.email || process.env.ARJUNA_EMAIL).toLowerCase(),
+      password: opts.password || process.env.ARJUNA_PASSWORD,
+    };
+    if (!opts.quiet && !opts.raw && !opts.json) console.error('Masuk ke akun...');
+    await login(client, profile.email, profile.password);
+  }
+
+  if (!opts.noClaim && opts.voucher) {
+    if (!opts.quiet && !opts.raw && !opts.json) console.error('Mengklaim kode...');
+    try {
+      claim = await claimCode(client, opts.voucher);
+    } catch (error) {
+      if (opts.command === 'login' && error instanceof ApiError && /already|sudah|claimed/i.test(error.message)) {
+        claim = { kind: 'already-claimed' };
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  if (!opts.quiet && !opts.raw && !opts.json) console.error('Mengambil API key...');
+  const account = await getAccount(client);
+  const result = {
+    name: account.name || profile.name || '',
+    email: account.email || profile.email,
+    ...(opts.command === 'create' ? { password: profile.password } : {}),
+    claim,
+    balance: account.token_balance,
+    status: account.status,
+    baseUrl: account.baseUrl,
+    apiKey: account.apiKey,
+  };
+
+  if (opts.save) result.savedKeyFile = secureAppend(opts.save, result.apiKey);
+  if (opts.accountOut) {
+    result.savedAccountFile = secureAppend(opts.accountOut, JSON.stringify({
+      name: result.name,
+      email: result.email,
+      password: profile.password,
+      apiKey: result.apiKey,
+      baseUrl: result.baseUrl,
+      balance: result.balance,
+      status: result.status,
+    }));
+  }
+
+  printResult(result, opts);
+}
+
+main().catch(error => {
+  const message = error instanceof ApiError && error.response?.data?.code
+    ? `${error.message} [${error.response.data.code}]`
+    : error.message;
+  console.error(`error=${message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@gelglx/arjunakey",
+  "version": "1.0.0",
+  "description": "Single-account CLI for OneStore registration, welcome-code claiming, and API-key retrieval",
+  "bin": {
+    "arjunakey": "cli.js"
+  },
+  "files": [
+    "cli.js",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node tests/smoke.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "preferGlobal": true,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "arjuna",
+    "onestore",
+    "api-key",
+    "cli",
+    "ai-gateway"
+  ]
+}