@globio/cli 0.0.1 → 0.1.1

package/src/auth/login.ts

@@ -0,0 +1,72 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { config } from '../lib/config.js';
+import { getCliVersion, muted, orange, printBanner } from '../lib/banner.js';
+
+const DEFAULT_BASE_URL = 'https://api.globio.stanlink.online';
+const version = getCliVersion();
+
+export async function login() {
+  printBanner(version);
+
+  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(
+      '  Logged in.\n\n' +
+        '  ' +
+        muted('API Key:  ') +
+        orange(values.apiKey as string) +
+        '\n' +
+        '  ' +
+        muted('Project:  ') +
+        orange(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,190 @@
+import chalk from 'chalk';
+import type { CodeFunction, CodeInvocation } from '@globio/sdk';
+import ora from 'ora';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { gold, muted, orange } from '../lib/banner.js';
+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 ? '\x1b[32m●\x1b[0m' : '\x1b[2m○\x1b[0m';
+    const type =
+      fn.type === 'hook' ? gold('[hook]') : orange('[function]');
+    console.log('  ' + status + '  ' + type + '  ' + fn.slug);
+    if (fn.type === 'hook' && fn.trigger_event) {
+      console.log(muted('           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(orange('Result:'));
+  console.log(JSON.stringify(result.data.result, null, 2));
+  console.log(muted(`\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
+      ? '\x1b[38;2;244;140;6m✓\x1b[0m'
+      : '\x1b[31m✗\x1b[0m';
+    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,75 @@
+import * as p from '@clack/prompts';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { config } from '../lib/config.js';
+import {
+  getCliVersion,
+  muted,
+  orange,
+  printSuccess,
+  printBanner,
+} from '../lib/banner.js';
+import { promptInit } from '../prompts/init.js';
+import { migrateFirestore, migrateFirebaseStorage } from './migrate.js';
+
+const version = getCliVersion();
+
+export async function init() {
+  printBanner(version);
+  p.intro(orange('⇒⇒') + '  Initialize your Globio project');
+
+  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!,
+});
+`
+    );
+    printSuccess('Created globio.config.ts');
+  }
+
+  if (!existsSync('.env')) {
+    writeFileSync('.env', `GLOBIO_API_KEY=${values.apiKey}\n`);
+    printSuccess('Created .env');
+  }
+
+  if (values.migrateFromFirebase && values.serviceAccountPath) {
+    console.log('');
+    printSuccess('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(
+    orange('⇒⇒') +
+      '  Your project is ready.\n\n' +
+      '  ' +
+      muted('Next steps:') +
+      '\n\n' +
+      '  npm install @globio/sdk\n' +
+      '  npx @globio/cli functions create my-first-function'
+  );
+}

package/src/commands/migrate.ts

@@ -0,0 +1,199 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { basename } from 'path';
+import {
+  getCliVersion,
+  gold,
+  muted,
+  orange,
+  printBanner,
+} from '../lib/banner.js';
+import { initFirebase } from '../lib/firebase.js';
+import { createProgressBar } from '../lib/progress.js';
+import { getClient } from '../lib/sdk.js';
+
+const version = getCliVersion();
+
+interface MigrateFirestoreOptions {
+  from: string;
+  collection?: string;
+  all?: boolean;
+}
+
+interface MigrateStorageOptions {
+  from: string;
+  bucket: string;
+  folder?: string;
+  all?: boolean;
+}
+
+export async function migrateFirestore(options: MigrateFirestoreOptions) {
+  printBanner(version);
+  p.intro(gold('⇒⇒') + '  Firebase → Globio Migration');
+
+  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('  ' + orange(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(
+    orange('✓') +
+      '  Migration complete.\n\n' +
+      '  ' +
+      muted('Your Firebase data is intact.') +
+      '\n' +
+      '  ' +
+      muted('Delete it manually when ready.')
+  );
+}
+
+export async function migrateFirebaseStorage(options: MigrateStorageOptions) {
+  printBanner(version);
+  p.intro(gold('⇒⇒') + '  Firebase → Globio Migration');
+
+  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(
+    orange('✓') +
+      '  Migration complete.\n\n' +
+      '  ' +
+      muted('Your Firebase data is intact.') +
+      '\n' +
+      '  ' +
+      muted('Delete it manually when ready.')
+  );
+}

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('');
+}