@globio/cli 0.0.1 → 0.1.0

package/src/auth/login.ts

@@ -0,0 +1,65 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { config } from '../lib/config.js';
+
+const DEFAULT_BASE_URL = 'https://api.globio.stanlink.online';
+
+export async function login() {
+  console.log('');
+  p.intro(chalk.bgCyan(chalk.black(' Globio CLI ')));
+
+  const values = await p.group(
+    {
+      apiKey: () =>
+        p.text({
+          message: 'Paste your Globio API key',
+          placeholder: 'gk_live_...',
+          validate: (value) => (!value ? 'API key is required' : undefined),
+        }),
+      projectId: () =>
+        p.text({
+          message: 'Paste your Project ID',
+          placeholder: 'proj_...',
+          validate: (value) => (!value ? 'Project ID is required' : undefined),
+        }),
+    },
+    {
+      onCancel: () => {
+        p.cancel('Login cancelled.');
+        process.exit(0);
+      },
+    }
+  );
+
+  const spinner = p.spinner();
+  spinner.start('Validating credentials...');
+
+  try {
+    const response = await fetch(`${DEFAULT_BASE_URL}/id/health`, {
+      headers: {
+        'X-Globio-Key': values.apiKey as string,
+      },
+    });
+
+    if (!response.ok) {
+      spinner.stop('Validation failed.');
+      p.outro(chalk.red('Invalid API key or project ID.'));
+      process.exit(1);
+    }
+
+    config.set({
+      apiKey: values.apiKey as string,
+      projectId: values.projectId as string,
+    });
+
+    spinner.stop('Credentials validated.');
+    p.outro(
+      chalk.green('Logged in. Active project: ') +
+        chalk.cyan(values.projectId as string)
+    );
+  } catch {
+    spinner.stop('');
+    p.outro(chalk.red('Could not connect to Globio. Check your credentials.'));
+    process.exit(1);
+  }
+}

package/src/auth/logout.ts

@@ -0,0 +1,8 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { config } from '../lib/config.js';
+
+export async function logout() {
+  config.clear();
+  p.outro(chalk.green('Logged out.'));
+}

package/src/auth/whoami.ts

@@ -0,0 +1,15 @@
+import chalk from 'chalk';
+import { config } from '../lib/config.js';
+
+export async function whoami() {
+  const cfg = config.get();
+  if (!cfg.apiKey) {
+    console.log(chalk.red('Not logged in.'));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.cyan('API Key:   ') + cfg.apiKey);
+  console.log(chalk.cyan('Project:   ') + (cfg.projectId ?? 'none'));
+  console.log('');
+}

package/src/commands/functions.ts

@@ -0,0 +1,191 @@
+import chalk from 'chalk';
+import type { CodeFunction, CodeInvocation } from '@globio/sdk';
+import ora from 'ora';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { getClient } from '../lib/sdk.js';
+
+export async function functionsList() {
+  const client = getClient();
+  const spinner = ora('Fetching functions...').start();
+  const result = await client.code.listFunctions();
+  spinner.stop();
+
+  if (!result.success || !result.data.length) {
+    console.log(chalk.gray('No functions found.'));
+    return;
+  }
+
+  console.log('');
+  result.data.forEach((fn: CodeFunction) => {
+    const status = fn.active
+      ? chalk.green('● active')
+      : chalk.gray('○ inactive');
+    const type =
+      fn.type === 'hook'
+        ? chalk.yellow('[hook]')
+        : chalk.cyan('[function]');
+    console.log(`  ${status}  ${type}  ${chalk.white(fn.slug)}`);
+    if (fn.type === 'hook') {
+      console.log(chalk.gray(`           trigger: ${fn.trigger_event}`));
+    }
+  });
+  console.log('');
+}
+
+export async function functionsCreate(slug: string) {
+  const filename = `${slug}.js`;
+  if (existsSync(filename)) {
+    console.log(chalk.yellow(`${filename} already exists.`));
+    return;
+  }
+
+  const template = `/**
+ * Globio Edge Function: ${slug}
+ * Invoke: npx @globio/cli functions invoke ${slug} --input '{"key":"value"}'
+ */
+async function handler(input, globio) {
+  // input: the payload from the caller
+  // globio: injected SDK — access all Globio services
+  // Example: const player = await globio.doc.get('players', input.userId);
+
+  return {
+    ok: true,
+    received: input,
+  };
+}
+`;
+  writeFileSync(filename, template);
+  console.log(chalk.green(`Created ${filename}`));
+  console.log(
+    chalk.gray(`Deploy with: npx @globio/cli functions deploy ${slug}`)
+  );
+}
+
+export async function functionsDeploy(
+  slug: string,
+  options: { file?: string; name?: string }
+) {
+  const filename = options.file ?? `${slug}.js`;
+  if (!existsSync(filename)) {
+    console.log(
+      chalk.red(
+        `File not found: ${filename}. Create it with: npx @globio/cli functions create ${slug}`
+      )
+    );
+    process.exit(1);
+  }
+
+  const code = readFileSync(filename, 'utf-8');
+  const client = getClient();
+  const spinner = ora(`Deploying ${slug}...`).start();
+  const existing = await client.code.getFunction(slug);
+
+  let result;
+  if (existing.success) {
+    result = await client.code.updateFunction(slug, {
+      code,
+      name: options.name ?? slug,
+    });
+  } else {
+    result = await client.code.createFunction({
+      name: options.name ?? slug,
+      slug,
+      type: 'function',
+      code,
+    });
+  }
+
+  if (!result.success) {
+    spinner.fail('Deploy failed');
+    console.error(result.error.message);
+    process.exit(1);
+  }
+
+  spinner.succeed(existing.success ? `Updated ${slug}` : `Deployed ${slug}`);
+}
+
+export async function functionsInvoke(
+  slug: string,
+  options: { input?: string }
+) {
+  let input: Record<string, unknown> = {};
+  if (options.input) {
+    try {
+      input = JSON.parse(options.input) as Record<string, unknown>;
+    } catch {
+      console.error(chalk.red('--input must be valid JSON'));
+      process.exit(1);
+    }
+  }
+
+  const client = getClient();
+  const spinner = ora(`Invoking ${slug}...`).start();
+  const result = await client.code.invoke(slug, input);
+  spinner.stop();
+
+  if (!result.success) {
+    console.log(chalk.red('Invocation failed'));
+    console.error(result.error.message);
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.cyan('Result:'));
+  console.log(JSON.stringify(result.data.result, null, 2));
+  console.log(chalk.gray(`\nDuration: ${result.data.duration_ms}ms`));
+}
+
+export async function functionsLogs(
+  slug: string,
+  options: { limit?: string }
+) {
+  const limit = options.limit ? parseInt(options.limit, 10) : 20;
+  const client = getClient();
+  const spinner = ora('Fetching invocations...').start();
+  const result = await client.code.getInvocations(slug, limit);
+  spinner.stop();
+
+  if (!result.success || !result.data.length) {
+    console.log(chalk.gray('No invocations yet.'));
+    return;
+  }
+
+  console.log('');
+  result.data.forEach((inv: CodeInvocation) => {
+    const status = inv.success ? chalk.green('✓') : chalk.red('✗');
+    const date = new Date(inv.invoked_at * 1000)
+      .toISOString()
+      .replace('T', ' ')
+      .slice(0, 19);
+    console.log(
+      `  ${status}  ${chalk.gray(date)}  ${inv.duration_ms}ms  ${chalk.gray(`[${inv.trigger_type}]`)}`
+    );
+  });
+  console.log('');
+}
+
+export async function functionsDelete(slug: string) {
+  const client = getClient();
+  const spinner = ora(`Deleting ${slug}...`).start();
+  const result = await client.code.deleteFunction(slug);
+  if (!result.success) {
+    spinner.fail(`Delete failed for ${slug}`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  spinner.succeed(`Deleted ${slug}`);
+}
+
+export async function functionsToggle(slug: string, active: boolean) {
+  const client = getClient();
+  const spinner = ora(
+    `${active ? 'Enabling' : 'Disabling'} ${slug}...`
+  ).start();
+  const result = await client.code.toggleFunction(slug, active);
+  if (!result.success) {
+    spinner.fail(`Toggle failed for ${slug}`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  spinner.succeed(`${slug} is now ${active ? 'active' : 'inactive'}`);
+}

package/src/commands/init.ts

@@ -0,0 +1,65 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { config } from '../lib/config.js';
+import { promptInit } from '../prompts/init.js';
+import { migrateFirestore, migrateFirebaseStorage } from './migrate.js';
+
+export async function init() {
+  console.log('');
+  p.intro(chalk.bgCyan(chalk.black(' Globio — Game Backend as a Service ')));
+
+  const values = await promptInit();
+
+  config.set({
+    apiKey: values.apiKey as string,
+    projectId: values.projectId as string,
+  });
+
+  if (!existsSync('globio.config.ts')) {
+    writeFileSync(
+      'globio.config.ts',
+      `import { GlobioClient } from '@globio/sdk';
+
+export const globio = new GlobioClient({
+  apiKey: process.env.GLOBIO_API_KEY!,
+});
+`
+    );
+    console.log(chalk.green('✓ Created globio.config.ts'));
+  }
+
+  if (!existsSync('.env')) {
+    writeFileSync('.env', `GLOBIO_API_KEY=${values.apiKey}\n`);
+    console.log(chalk.green('✓ Created .env'));
+  }
+
+  if (values.migrateFromFirebase && values.serviceAccountPath) {
+    console.log('');
+    console.log(chalk.cyan('Starting Firebase migration...'));
+
+    await migrateFirestore({
+      from: values.serviceAccountPath as string,
+      all: true,
+    });
+
+    const serviceAccount = JSON.parse(
+      readFileSync(values.serviceAccountPath as string, 'utf-8')
+    ) as { project_id: string };
+
+    await migrateFirebaseStorage({
+      from: values.serviceAccountPath as string,
+      bucket: `${serviceAccount.project_id}.appspot.com`,
+      all: true,
+    });
+  }
+
+  console.log('');
+  p.outro(
+    chalk.green('Your Globio project is ready.') +
+      '\n\n' +
+      chalk.white('  Next steps:\n') +
+      chalk.gray('  npm install @globio/sdk\n') +
+      chalk.gray('  npx @globio/cli functions create my-first-function\n')
+  );
+}

package/src/commands/migrate.ts

@@ -0,0 +1,179 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { basename } from 'path';
+import { initFirebase } from '../lib/firebase.js';
+import { createProgressBar } from '../lib/progress.js';
+import { getClient } from '../lib/sdk.js';
+
+interface MigrateFirestoreOptions {
+  from: string;
+  collection?: string;
+  all?: boolean;
+}
+
+interface MigrateStorageOptions {
+  from: string;
+  bucket: string;
+  folder?: string;
+  all?: boolean;
+}
+
+export async function migrateFirestore(options: MigrateFirestoreOptions) {
+  console.log('');
+  p.intro(chalk.bgYellow(chalk.black(' Globio Migration — Firestore ')));
+
+  const { firestore } = await initFirebase(options.from);
+  const client = getClient();
+
+  let collections: string[] = [];
+
+  if (options.all) {
+    const snapshot = await firestore.listCollections();
+    collections = snapshot.map((collection) => collection.id);
+    console.log(
+      chalk.cyan(
+        `Found ${collections.length} collections: ${collections.join(', ')}`
+      )
+    );
+  } else if (options.collection) {
+    collections = [options.collection];
+  } else {
+    console.log(chalk.red('Specify --collection <name> or --all'));
+    process.exit(1);
+  }
+
+  const results: Record<
+    string,
+    { success: number; failed: number; failedIds: string[] }
+  > = {};
+
+  for (const collectionId of collections) {
+    console.log('');
+    console.log(chalk.cyan(`Migrating collection: ${collectionId}`));
+
+    const countSnap = await firestore.collection(collectionId).count().get();
+    const total = countSnap.data().count;
+
+    const bar = createProgressBar(collectionId);
+    bar.start(total, 0);
+
+    results[collectionId] = {
+      success: 0,
+      failed: 0,
+      failedIds: [],
+    };
+
+    let lastDoc: unknown = null;
+    let processed = 0;
+
+    while (processed < total) {
+      let query = firestore.collection(collectionId).limit(100);
+
+      if (lastDoc) {
+        query = query.startAfter(lastDoc as never);
+      }
+
+      const snapshot = await query.get();
+      if (snapshot.empty) {
+        break;
+      }
+
+      for (const doc of snapshot.docs) {
+        try {
+          const result = await client.doc.set(collectionId, doc.id, doc.data());
+          if (!result.success) {
+            throw new Error(result.error.message);
+          }
+          results[collectionId].success++;
+        } catch {
+          results[collectionId].failed++;
+          results[collectionId].failedIds.push(doc.id);
+        }
+        processed++;
+        bar.update(processed);
+      }
+
+      lastDoc = snapshot.docs[snapshot.docs.length - 1] ?? null;
+    }
+
+    bar.stop();
+
+    console.log(
+      chalk.green(`  ✓ ${results[collectionId].success} documents migrated`)
+    );
+    if (results[collectionId].failed > 0) {
+      console.log(chalk.red(`  ✗ ${results[collectionId].failed} failed`));
+      console.log(
+        chalk.gray(
+          '  Failed IDs: ' +
+            results[collectionId].failedIds.slice(0, 10).join(', ') +
+            (results[collectionId].failedIds.length > 10 ? '...' : '')
+        )
+      );
+    }
+  }
+
+  console.log('');
+  p.outro(chalk.green('Firestore migration complete.'));
+  console.log(
+    chalk.gray(
+      'Your Firebase data is intact. Delete it manually when ready.'
+    )
+  );
+}
+
+export async function migrateFirebaseStorage(options: MigrateStorageOptions) {
+  console.log('');
+  p.intro(chalk.bgYellow(chalk.black(' Globio Migration — Storage ')));
+
+  const { storage } = await initFirebase(options.from);
+  const client = getClient();
+
+  const bucketName = options.bucket.replace(/^gs:\/\//, '');
+  const bucket = storage.bucket(bucketName);
+  const prefix = options.folder ? options.folder.replace(/^\//, '') : '';
+
+  const [files] = await bucket.getFiles(prefix ? { prefix } : {});
+
+  console.log(chalk.cyan(`Found ${files.length} files to migrate`));
+
+  const bar = createProgressBar('Storage');
+  bar.start(files.length, 0);
+
+  let success = 0;
+  let failed = 0;
+
+  for (const file of files) {
+    try {
+      const [buffer] = await file.download();
+      const uploadFile = new File(
+        [new Uint8Array(buffer)],
+        basename(file.name) || file.name
+      );
+      const result = await client.vault.uploadFile(uploadFile, {
+        metadata: {
+          original_path: file.name,
+        },
+      });
+
+      if (!result.success) {
+        throw new Error(result.error.message);
+      }
+
+      success++;
+    } catch {
+      failed++;
+    }
+    bar.increment();
+  }
+
+  bar.stop();
+
+  console.log('');
+  console.log(chalk.green(`  ✓ ${success} files migrated`));
+  if (failed > 0) {
+    console.log(chalk.red(`  ✗ ${failed} failed`));
+  }
+
+  p.outro(chalk.green('Storage migration complete.'));
+}

package/src/commands/projects.ts

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+import { config } from '../lib/config.js';
+
+export async function projectsList() {
+  const cfg = config.get();
+  console.log('');
+  console.log(
+    chalk.cyan('Active project: ') + (cfg.projectId ?? chalk.gray('none'))
+  );
+  console.log('');
+}
+
+export async function projectsUse(projectId: string) {
+  config.set({ projectId });
+  console.log(chalk.green('Active project set to: ') + chalk.cyan(projectId));
+}

package/src/commands/services.ts

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+
+const ALL_SERVICES = [
+  'id',
+  'doc',
+  'vault',
+  'pulse',
+  'scope',
+  'sync',
+  'signal',
+  'mart',
+  'brain',
+  'code',
+];
+
+export async function servicesList() {
+  console.log('');
+  console.log(chalk.cyan('Available Globio services:'));
+  ALL_SERVICES.forEach((service) => {
+    console.log('  ' + chalk.white(service));
+  });
+  console.log('');
+  console.log(
+    chalk.gray('Manage service access via console.globio.stanlink.online')
+  );
+  console.log('');
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { login } from './auth/login.js';
+import { logout } from './auth/logout.js';
+import { whoami } from './auth/whoami.js';
+import { init } from './commands/init.js';
+import { projectsList, projectsUse } from './commands/projects.js';
+import { servicesList } from './commands/services.js';
+import {
+  functionsList,
+  functionsCreate,
+  functionsDeploy,
+  functionsInvoke,
+  functionsLogs,
+  functionsDelete,
+  functionsToggle,
+} from './commands/functions.js';
+import {
+  migrateFirestore,
+  migrateFirebaseStorage,
+} from './commands/migrate.js';
+
+const program = new Command();
+
+program
+  .name('globio')
+  .description('The official Globio CLI')
+    .version('0.1.0');
+
+program.command('login').description('Log in to your Globio account').action(login);
+program.command('logout').description('Log out').action(logout);
+program.command('whoami').description('Show current account and project').action(whoami);
+
+program.command('init').description('Initialize a Globio project').action(init);
+
+const projects = program.command('projects').description('Manage projects');
+projects.command('list').description('List projects').action(projectsList);
+projects.command('use <projectId>').description('Set active project').action(projectsUse);
+
+program.command('services').description('List available Globio services').action(servicesList);
+
+const functions = program
+  .command('functions')
+  .alias('fn')
+  .description('Manage GlobalCode edge functions');
+
+functions.command('list').description('List all functions').action(functionsList);
+functions.command('create <slug>').description('Scaffold a new function file locally').action(functionsCreate);
+functions
+  .command('deploy <slug>')
+  .description('Deploy a function to GlobalCode')
+  .option('-f, --file <path>', 'Path to function file')
+  .option('-n, --name <name>', 'Display name')
+  .action(functionsDeploy);
+functions
+  .command('invoke <slug>')
+  .description('Invoke a function')
+  .option('-i, --input <json>', 'JSON input payload')
+  .action(functionsInvoke);
+functions
+  .command('logs <slug>')
+  .description('Show invocation history')
+  .option('-l, --limit <n>', 'Number of entries', '20')
+  .action(functionsLogs);
+functions.command('delete <slug>').description('Delete a function').action(functionsDelete);
+functions.command('enable <slug>').description('Enable a function').action((slug) => functionsToggle(slug, true));
+functions.command('disable <slug>').description('Disable a function').action((slug) => functionsToggle(slug, false));
+
+const migrate = program
+  .command('migrate')
+  .description('Migrate from Firebase to Globio');
+
+migrate
+  .command('firestore')
+  .description('Migrate Firestore collections to GlobalDoc')
+  .requiredOption('--from <path>', 'Path to Firebase service account JSON')
+  .option('--collection <name>', 'Migrate a specific collection')
+  .option('--all', 'Migrate all collections')
+  .action(migrateFirestore);
+
+migrate
+  .command('firebase-storage')
+  .description('Migrate Firebase Storage to GlobalVault')
+  .requiredOption('--from <path>', 'Path to Firebase service account JSON')
+  .requiredOption('--bucket <name>', 'Firebase Storage bucket')
+  .option('--folder <path>', 'Migrate a specific folder')
+  .option('--all', 'Migrate all files')
+  .action(migrateFirebaseStorage);
+
+await program.parseAsync();