pushnetgo-cli 1.0.0

package/README.md

@@ -0,0 +1,96 @@
+# PushNetGo CLI
+
+Command-line tool for PushNetGo App — sync music, validate API keys. Designed for AI agents to invoke directly.
+
+## Install
+
+```bash
+npm install -g pushnetgo-cli
+```
+
+Or run without installing:
+
+```bash
+npx pushnetgo-cli token check --key pushnetgo-xxx
+```
+
+## HTTP API
+
+For AI agents that can't run local commands, use the HTTP API:
+
+```
+Endpoint: https://us-central1-flutter-ai-playground-f8e3b.cloudfunctions.net/unifiedGatewayApi
+Auth: x-api-key header
+Format: JSON POST { "action": "...", ...params }
+```
+
+### Actions
+
+#### token-check
+
+```bash
+curl -X POST https://us-central1-flutter-ai-playground-f8e3b.cloudfunctions.net/unifiedGatewayApi \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: pushnetgo-xxx" \
+  -d '{"action":"token-check"}'
+```
+
+#### sync-music
+
+Download an MP3 from URL and upload to PushNetGo project.
+
+```bash
+curl -X POST https://us-central1-flutter-ai-playground-f8e3b.cloudfunctions.net/unifiedGatewayApi \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: pushnetgo-xxx" \
+  -d '{"action":"sync-music","projectId":"my-project","url":"https://example.com/track.mp3"}'
+```
+
+## CLI Usage
+
+Set your API key as an environment variable:
+
+```bash
+export MYAPP_API_KEY="pushnetgo-xxx"
+```
+
+Or pass it with each command:
+
+```bash
+pushnetgo-cli --key pushnetgo-xxx <command>
+```
+
+### Commands
+
+#### sync-music
+
+Upload local MP3 files or import from URL:
+
+```bash
+# Upload from local directory
+pushnetgo-cli sync-music --project radio99 --dir /path/to/mp3
+
+# Import from URL
+pushnetgo-cli sync-music --project radio99 --url "https://api.mureka.ai/output.mp3"
+```
+
+#### token check
+
+Validate an API key:
+
+```bash
+pushnetgo-cli token check
+pushnetgo-cli token check --key pushnetgo-xxx
+```
+
+## API Key Format
+
+PushNetGo API keys use the format:
+
+```
+pushnetgo-{32-character-hex-uuid}
+```
+
+Example: `pushnetgo-6d122db2132d4a94a91a46e529fd2752`
+
+Keys are generated from the PushNetGo App Token Hub.

package/bin/pushnetgo-cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const program = new Command();
+
+program
+  .name('pushnetgo-cli')
+  .alias('png')
+  .description('PushNetGo App open project CLI — AI Agent can invoke via MYAPP_API_KEY env var')
+  .version('1.0.0');
+
+program
+  .command('sync-music')
+  .alias('sync')
+  .description('Sync music to App open project')
+  .option('-p, --project <id>', 'target project ID', 'default')
+  .option('-d, --dir <path>', 'local MP3 directory')
+  .option('-u, --url <url>', 'Mureka AI generated music URL')
+  .option('-k, --key <token>', 'API Key (or set MYAPP_API_KEY env var)')
+  .action(async (options) => {
+    const { syncMusic } = require('../commands/sync-music');
+    await syncMusic(options);
+  });
+
+program
+  .command('token <action>')
+  .description('Token management: check')
+  .option('-k, --key <token>', 'API Key')
+  .action(async (action, options) => {
+    if (action === 'check') {
+      const { checkToken } = require('../commands/token');
+      await checkToken(options.key);
+    } else {
+      console.error(`Unknown action: ${action}. Use: check`);
+    }
+  });
+
+program.parse(process.argv);

package/commands/sync-music.js

@@ -0,0 +1,63 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { resolveApiKey } = require('../lib/auth');
+const { uploadFile, saveTrack, downloadUrlToFile } = require('../lib/uploader');
+
+async function syncMusic(options) {
+  const projectId = options.project || 'default';
+  const dir = options.dir;
+  const url = options.url;
+
+  await resolveApiKey(options.key);
+
+  if (dir) {
+    const files = fs.readdirSync(dir)
+      .filter(f => f.endsWith('.mp3'))
+      .map(f => path.join(dir, f));
+
+    console.log(`${files.length} MP3 files, project: ${projectId}\n`);
+
+    let ok = 0;
+    for (let i = 0; i < files.length; i++) {
+      const fp = files[i];
+      const name = path.basename(fp, '.mp3');
+      const [artist = 'Unknown', ...titleParts] = name.split(' - ');
+      const title = titleParts.join(' - ') || name;
+      const trackId = `cli_${Date.now()}_${i}`;
+
+      try {
+        process.stdout.write(`[${i + 1}/${files.length}] ^ ${artist} - ${title}...`);
+        const downloadUrl = await uploadFile(fp, `music_files/${trackId}.mp3`);
+        await saveTrack({ trackId, title, artist, downloadUrl, projectId });
+        console.log(' OK');
+        ok++;
+      } catch (e) {
+        console.log(' FAIL', e.message);
+      }
+    }
+    console.log(`\nDone: ${ok}/${files.length} uploaded`);
+  }
+
+  if (url) {
+    console.log(`Download: ${url}`);
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `mureka_${Date.now()}.mp3`);
+    await downloadUrlToFile(url, tmpFile);
+    console.log(`Downloaded to: ${tmpFile}`);
+
+    const trackId = `mureka_${Date.now()}`;
+    const artist = 'Mureka AI';
+    const title = `Generated ${new Date().toISOString().slice(0, 10)}`;
+
+    process.stdout.write('Uploading...');
+    const downloadUrl = await uploadFile(tmpFile, `music_files/${trackId}.mp3`);
+    await saveTrack({ trackId, title, artist, downloadUrl, projectId });
+    console.log(' OK');
+
+    try { fs.unlinkSync(tmpFile); } catch (_) {}
+    console.log(`Mureka track published to project ${projectId}`);
+  }
+}
+
+module.exports = { syncMusic };

package/commands/token.js

@@ -0,0 +1,37 @@
+const { getFirestore } = require('../lib/firestore');
+
+async function checkToken(key) {
+  const token = key || process.env.MYAPP_API_KEY;
+
+  if (!token) {
+    console.error('Usage: pushnetgo-cli token check --key pushnetgo-xxxx');
+    console.error('   or: export MYAPP_API_KEY="pushnetgo-xxxx"');
+    process.exit(1);
+  }
+
+  if (!token.startsWith('pushnetgo-')) {
+    console.error('Invalid prefix. PushNetGo keys must start with pushnetgo-');
+    process.exit(1);
+  }
+
+  const db = getFirestore();
+  const snap = await db.collection('tokens')
+    .where('tokenValue', '==', token)
+    .limit(1)
+    .get();
+
+  if (snap.empty) {
+    console.log(`NOT FOUND: ${token.slice(0, 16)}...`);
+    return;
+  }
+
+  const d = snap.docs[0].data();
+  console.log(`OK: ${token}`);
+  console.log(`   active:    ${d.isActive}`);
+  console.log(`   usage:     ${d.usageCount || 0}`);
+  console.log(`   userId:    ${d.userId}`);
+  console.log(`   perms:     ${JSON.stringify(d.permissions || d.scopes || [])}`);
+  console.log(`   created:   ${d.createdAt?.toDate?.() || d.createdAt}`);
+}
+
+module.exports = { checkToken };

package/lib/auth.js

@@ -0,0 +1,49 @@
+const { getFirestore, admin } = require('./firestore');
+
+async function resolveApiKey(cliKey) {
+  const key = cliKey || process.env.MYAPP_API_KEY;
+
+  if (!key) {
+    console.error('No API Key found. Set env var or pass --key:');
+  console.error('  export MYAPP_API_KEY="pushnetgo-xxxx"');
+  console.error('  or: pushnetgo-cli sync-music --key pushnetgo-xxxx ...');
+    process.exit(1);
+  }
+
+  if (!key.startsWith('pushnetgo-') || key.length < 22) {
+    console.error('Invalid key format. Expected pushnetgo- prefix + 32 hex chars');
+    process.exit(1);
+  }
+
+  const db = getFirestore();
+  const snap = await db.collection('tokens')
+    .where('tokenValue', '==', key)
+    .where('isActive', '==', true)
+    .limit(1)
+    .get();
+
+  if (snap.empty) {
+    console.error('Key not found or inactive');
+    process.exit(1);
+  }
+
+  const data = snap.docs[0].data();
+  const perms = data.permissions || data.scopes || [];
+  const hasUpload = perms.some(p => p === 'musicUpload' || p === 'music_upload');
+
+  if (!hasUpload) {
+    console.error('This key lacks musicUpload permission');
+    process.exit(1);
+  }
+
+  console.log(`Auth OK — uid: ${data.userId}`);
+
+  await db.collection('tokens').doc(snap.docs[0].id).update({
+    lastUsedAt: admin.firestore.FieldValue.serverTimestamp(),
+    usageCount: admin.firestore.FieldValue.increment(1),
+  });
+
+  return key;
+}
+
+module.exports = { resolveApiKey };

package/lib/firestore.js

@@ -0,0 +1,23 @@
+const admin = require('firebase-admin');
+const path = require('path');
+
+let _initialized = false;
+
+function getFirestore() {
+  if (!_initialized) {
+    const saPath = path.resolve(__dirname, '../../configs/service-account.json');
+    admin.initializeApp({
+      credential: admin.credential.cert(require(saPath)),
+      storageBucket: 'flutter-ai-playground-f8e3b.firebasestorage.app',
+    });
+    _initialized = true;
+  }
+  return admin.firestore();
+}
+
+function getStorage() {
+  getFirestore();
+  return admin.storage().bucket();
+}
+
+module.exports = { getFirestore, getStorage, admin };

package/lib/uploader.js

@@ -0,0 +1,56 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { getStorage, getFirestore, admin } = require('./firestore');
+
+async function uploadFile(filePath, remotePath) {
+  const bucket = getStorage();
+  await bucket.upload(filePath, {
+    destination: remotePath,
+    metadata: { contentType: 'audio/mpeg' },
+  });
+  const file = bucket.file(remotePath);
+  await file.makePublic();
+  return `https://storage.googleapis.com/${bucket.name}/${remotePath}`;
+}
+
+async function saveTrack({ trackId, title, artist, downloadUrl, projectId }) {
+  const db = getFirestore();
+  await db.collection('musics').doc(trackId).set({
+    title,
+    artist,
+    musicUrl: downloadUrl,
+    duration: '0:00',
+    plays: 0,
+    likesCount: 0,
+    projectId: projectId || 'default',
+    publisherId: 'cli_upload',
+    publisherName: 'PushNetGo CLI',
+    createdAt: admin.firestore.FieldValue.serverTimestamp(),
+  });
+}
+
+async function downloadUrlToFile(url, destPath) {
+  const client = url.startsWith('https') ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    client.get(url, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        file.close();
+        fs.unlinkSync(destPath);
+        downloadUrlToFile(response.headers.location, destPath).then(resolve).catch(reject);
+        return;
+      }
+      response.pipe(file);
+      file.on('finish', () => { file.close(); resolve(destPath); });
+    }).on('error', (err) => {
+      file.close();
+      try { fs.unlinkSync(destPath); } catch (_) {}
+      reject(err);
+    });
+  });
+}
+
+module.exports = { uploadFile, saveTrack, downloadUrlToFile };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "pushnetgo-cli",
+  "version": "1.0.0",
+  "description": "PushNetGo App CLI — sync music, validate tokens via HTTP API or local Firebase SDK",
+  "bin": {
+    "pushnetgo-cli": "./bin/pushnetgo-cli.js"
+  },
+  "scripts": {
+    "start": "node bin/pushnetgo-cli.js"
+  },
+  "keywords": ["pushnetgo", "music", "sync", "cli", "ai-agent"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pushnetgo/pushnetgo-cli"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "firebase-admin": "^12.0.0",
+    "chalk": "^5.0.0"
+  }
+}