@globio/cli 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,2 +1,644 @@
 #!/usr/bin/env node
-console.log("globio CLI placeholder");
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/auth/login.ts
+import * as p from "@clack/prompts";
+import chalk2 from "chalk";
+
+// src/lib/config.ts
+import chalk from "chalk";
+import Conf from "conf";
+var store = new Conf({
+  projectName: "globio",
+  defaults: {}
+});
+var config = {
+  get: () => store.store,
+  set: (values) => {
+    Object.entries(values).forEach(([key, value]) => {
+      if (value !== void 0) {
+        store.set(key, value);
+      }
+    });
+  },
+  clear: () => store.clear(),
+  getApiKey: () => store.get("apiKey"),
+  requireAuth: () => {
+    const key = store.get("apiKey");
+    if (!key) {
+      console.error(chalk.red("Not logged in. Run: npx @globio/cli login"));
+      process.exit(1);
+    }
+    return key;
+  },
+  requireProject: () => {
+    const projectId = store.get("projectId");
+    if (!projectId) {
+      console.error(
+        chalk.red("No active project. Run: npx @globio/cli projects use <projectId>")
+      );
+      process.exit(1);
+    }
+    return projectId;
+  }
+};
+
+// src/lib/banner.ts
+import { readFileSync } from "fs";
+import figlet from "figlet";
+import gradientString from "gradient-string";
+var globioGradient = gradientString(
+  "#e85d04",
+  "#f48c06",
+  "#faa307",
+  "#ffba08",
+  "#ffd000"
+);
+function printBanner(version5) {
+  const art = figlet.textSync("Globio", {
+    font: "ANSI Shadow",
+    horizontalLayout: "default"
+  });
+  console.log(globioGradient.multiline(art));
+  console.log(
+    globioGradient("  \u21D2\u21D2") + "  Game Backend as a Service  \x1B[2mv" + version5 + "\x1B[0m"
+  );
+  console.log("");
+}
+function printSuccess(message) {
+  console.log("\x1B[38;2;250;163;7m\u2713\x1B[0m  " + message);
+}
+var orange = (s) => "\x1B[38;2;244;140;6m" + s + "\x1B[0m";
+var gold = (s) => "\x1B[38;2;255;208;0m" + s + "\x1B[0m";
+var muted = (s) => "\x1B[2m" + s + "\x1B[0m";
+function getCliVersion() {
+  const file = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  return JSON.parse(file).version;
+}
+
+// src/auth/login.ts
+var DEFAULT_BASE_URL = "https://api.globio.stanlink.online";
+var version = getCliVersion();
+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" : void 0
+      }),
+      projectId: () => p.text({
+        message: "Paste your Project ID",
+        placeholder: "proj_...",
+        validate: (value) => !value ? "Project ID is required" : void 0
+      })
+    },
+    {
+      onCancel: () => {
+        p.cancel("Login cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  const spinner2 = p.spinner();
+  spinner2.start("Validating credentials...");
+  try {
+    const response = await fetch(`${DEFAULT_BASE_URL}/id/health`, {
+      headers: {
+        "X-Globio-Key": values.apiKey
+      }
+    });
+    if (!response.ok) {
+      spinner2.stop("Validation failed.");
+      p.outro(chalk2.red("Invalid API key or project ID."));
+      process.exit(1);
+    }
+    config.set({
+      apiKey: values.apiKey,
+      projectId: values.projectId
+    });
+    spinner2.stop("Credentials validated.");
+    p.outro(
+      "  Logged in.\n\n  " + muted("API Key:  ") + orange(values.apiKey) + "\n  " + muted("Project:  ") + orange(values.projectId)
+    );
+  } catch {
+    spinner2.stop("");
+    p.outro(chalk2.red("Could not connect to Globio. Check your credentials."));
+    process.exit(1);
+  }
+}
+
+// src/auth/logout.ts
+import * as p2 from "@clack/prompts";
+import chalk3 from "chalk";
+async function logout() {
+  config.clear();
+  p2.outro(chalk3.green("Logged out."));
+}
+
+// src/auth/whoami.ts
+import chalk4 from "chalk";
+async function whoami() {
+  const cfg = config.get();
+  if (!cfg.apiKey) {
+    console.log(chalk4.red("Not logged in."));
+    return;
+  }
+  console.log("");
+  console.log(chalk4.cyan("API Key:   ") + cfg.apiKey);
+  console.log(chalk4.cyan("Project:   ") + (cfg.projectId ?? "none"));
+  console.log("");
+}
+
+// src/commands/init.ts
+import * as p5 from "@clack/prompts";
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+
+// src/prompts/init.ts
+import * as p3 from "@clack/prompts";
+async function promptInit() {
+  return p3.group(
+    {
+      apiKey: () => p3.text({
+        message: "Globio API key",
+        placeholder: "gk_live_...",
+        validate: (value) => !value ? "Required" : void 0
+      }),
+      projectId: () => p3.text({
+        message: "Project ID",
+        placeholder: "proj_...",
+        validate: (value) => !value ? "Required" : void 0
+      }),
+      migrateFromFirebase: () => p3.confirm({
+        message: "Migrating from Firebase?",
+        initialValue: false
+      }),
+      serviceAccountPath: ({ results }) => results.migrateFromFirebase ? p3.text({
+        message: "Path to Firebase service account JSON",
+        placeholder: "./serviceAccountKey.json"
+      }) : Promise.resolve(void 0)
+    },
+    {
+      onCancel: () => {
+        p3.cancel("Cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+}
+
+// src/commands/migrate.ts
+import * as p4 from "@clack/prompts";
+import chalk6 from "chalk";
+import { basename } from "path";
+
+// src/lib/firebase.ts
+async function initFirebase(serviceAccountPath) {
+  const admin = await import("firebase-admin");
+  const { readFileSync: readFileSync4 } = await import("fs");
+  const serviceAccount = JSON.parse(readFileSync4(serviceAccountPath, "utf-8"));
+  if (!admin.default.apps.length) {
+    admin.default.initializeApp({
+      credential: admin.default.credential.cert(serviceAccount),
+      storageBucket: serviceAccount.project_id + ".appspot.com"
+    });
+  }
+  return {
+    firestore: admin.default.firestore(),
+    storage: admin.default.storage(),
+    app: admin.default.app()
+  };
+}
+
+// src/lib/progress.ts
+import chalk5 from "chalk";
+import cliProgress from "cli-progress";
+function createProgressBar(label) {
+  const bar = new cliProgress.SingleBar(
+    {
+      format: chalk5.cyan(label) + " [{bar}] {percentage}% | {value}/{total}",
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      hideCursor: true
+    },
+    cliProgress.Presets.shades_classic
+  );
+  return bar;
+}
+
+// src/lib/sdk.ts
+import { Globio } from "@globio/sdk";
+function getClient() {
+  const apiKey = config.requireAuth();
+  config.requireProject();
+  return new Globio({ apiKey });
+}
+
+// src/commands/migrate.ts
+var version2 = getCliVersion();
+async function migrateFirestore(options) {
+  printBanner(version2);
+  p4.intro(gold("\u21D2\u21D2") + "  Firebase \u2192 Globio Migration");
+  const { firestore } = await initFirebase(options.from);
+  const client = getClient();
+  let collections = [];
+  if (options.all) {
+    const snapshot = await firestore.listCollections();
+    collections = snapshot.map((collection) => collection.id);
+    console.log(
+      chalk6.cyan(
+        `Found ${collections.length} collections: ${collections.join(", ")}`
+      )
+    );
+  } else if (options.collection) {
+    collections = [options.collection];
+  } else {
+    console.log(chalk6.red("Specify --collection <name> or --all"));
+    process.exit(1);
+  }
+  const results = {};
+  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 = null;
+    let processed = 0;
+    while (processed < total) {
+      let query = firestore.collection(collectionId).limit(100);
+      if (lastDoc) {
+        query = query.startAfter(lastDoc);
+      }
+      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(
+      chalk6.green(`  \u2713 ${results[collectionId].success} documents migrated`)
+    );
+    if (results[collectionId].failed > 0) {
+      console.log(chalk6.red(`  \u2717 ${results[collectionId].failed} failed`));
+      console.log(
+        chalk6.gray(
+          "  Failed IDs: " + results[collectionId].failedIds.slice(0, 10).join(", ") + (results[collectionId].failedIds.length > 10 ? "..." : "")
+        )
+      );
+    }
+  }
+  console.log("");
+  p4.outro(
+    orange("\u2713") + "  Migration complete.\n\n  " + muted("Your Firebase data is intact.") + "\n  " + muted("Delete it manually when ready.")
+  );
+}
+async function migrateFirebaseStorage(options) {
+  printBanner(version2);
+  p4.intro(gold("\u21D2\u21D2") + "  Firebase \u2192 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(chalk6.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(chalk6.green(`  \u2713 ${success} files migrated`));
+  if (failed > 0) {
+    console.log(chalk6.red(`  \u2717 ${failed} failed`));
+  }
+  p4.outro(
+    orange("\u2713") + "  Migration complete.\n\n  " + muted("Your Firebase data is intact.") + "\n  " + muted("Delete it manually when ready.")
+  );
+}
+
+// src/commands/init.ts
+var version3 = getCliVersion();
+async function init() {
+  printBanner(version3);
+  p5.intro(orange("\u21D2\u21D2") + "  Initialize your Globio project");
+  const values = await promptInit();
+  config.set({
+    apiKey: values.apiKey,
+    projectId: values.projectId
+  });
+  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}
+`);
+    printSuccess("Created .env");
+  }
+  if (values.migrateFromFirebase && values.serviceAccountPath) {
+    console.log("");
+    printSuccess("Starting Firebase migration...");
+    await migrateFirestore({
+      from: values.serviceAccountPath,
+      all: true
+    });
+    const serviceAccount = JSON.parse(
+      readFileSync2(values.serviceAccountPath, "utf-8")
+    );
+    await migrateFirebaseStorage({
+      from: values.serviceAccountPath,
+      bucket: `${serviceAccount.project_id}.appspot.com`,
+      all: true
+    });
+  }
+  console.log("");
+  p5.outro(
+    orange("\u21D2\u21D2") + "  Your project is ready.\n\n  " + muted("Next steps:") + "\n\n  npm install @globio/sdk\n  npx @globio/cli functions create my-first-function"
+  );
+}
+
+// src/commands/projects.ts
+import chalk7 from "chalk";
+async function projectsList() {
+  const cfg = config.get();
+  console.log("");
+  console.log(
+    chalk7.cyan("Active project: ") + (cfg.projectId ?? chalk7.gray("none"))
+  );
+  console.log("");
+}
+async function projectsUse(projectId) {
+  config.set({ projectId });
+  console.log(chalk7.green("Active project set to: ") + chalk7.cyan(projectId));
+}
+
+// src/commands/services.ts
+import chalk8 from "chalk";
+var ALL_SERVICES = [
+  "id",
+  "doc",
+  "vault",
+  "pulse",
+  "scope",
+  "sync",
+  "signal",
+  "mart",
+  "brain",
+  "code"
+];
+async function servicesList() {
+  console.log("");
+  console.log(chalk8.cyan("Available Globio services:"));
+  ALL_SERVICES.forEach((service) => {
+    console.log("  " + chalk8.white(service));
+  });
+  console.log("");
+  console.log(
+    chalk8.gray("Manage service access via console.globio.stanlink.online")
+  );
+  console.log("");
+}
+
+// src/commands/functions.ts
+import chalk9 from "chalk";
+import ora from "ora";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+async function functionsList() {
+  const client = getClient();
+  const spinner2 = ora("Fetching functions...").start();
+  const result = await client.code.listFunctions();
+  spinner2.stop();
+  if (!result.success || !result.data.length) {
+    console.log(chalk9.gray("No functions found."));
+    return;
+  }
+  console.log("");
+  result.data.forEach((fn) => {
+    const status = fn.active ? "\x1B[32m\u25CF\x1B[0m" : "\x1B[2m\u25CB\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("");
+}
+async function functionsCreate(slug) {
+  const filename = `${slug}.js`;
+  if (existsSync2(filename)) {
+    console.log(chalk9.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 \u2014 access all Globio services
+  // Example: const player = await globio.doc.get('players', input.userId);
+
+  return {
+    ok: true,
+    received: input,
+  };
+}
+`;
+  writeFileSync2(filename, template);
+  console.log(chalk9.green(`Created ${filename}`));
+  console.log(
+    chalk9.gray(`Deploy with: npx @globio/cli functions deploy ${slug}`)
+  );
+}
+async function functionsDeploy(slug, options) {
+  const filename = options.file ?? `${slug}.js`;
+  if (!existsSync2(filename)) {
+    console.log(
+      chalk9.red(
+        `File not found: ${filename}. Create it with: npx @globio/cli functions create ${slug}`
+      )
+    );
+    process.exit(1);
+  }
+  const code = readFileSync3(filename, "utf-8");
+  const client = getClient();
+  const spinner2 = 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) {
+    spinner2.fail("Deploy failed");
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  spinner2.succeed(existing.success ? `Updated ${slug}` : `Deployed ${slug}`);
+}
+async function functionsInvoke(slug, options) {
+  let input = {};
+  if (options.input) {
+    try {
+      input = JSON.parse(options.input);
+    } catch {
+      console.error(chalk9.red("--input must be valid JSON"));
+      process.exit(1);
+    }
+  }
+  const client = getClient();
+  const spinner2 = ora(`Invoking ${slug}...`).start();
+  const result = await client.code.invoke(slug, input);
+  spinner2.stop();
+  if (!result.success) {
+    console.log(chalk9.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(`
+Duration: ${result.data.duration_ms}ms`));
+}
+async function functionsLogs(slug, options) {
+  const limit = options.limit ? parseInt(options.limit, 10) : 20;
+  const client = getClient();
+  const spinner2 = ora("Fetching invocations...").start();
+  const result = await client.code.getInvocations(slug, limit);
+  spinner2.stop();
+  if (!result.success || !result.data.length) {
+    console.log(chalk9.gray("No invocations yet."));
+    return;
+  }
+  console.log("");
+  result.data.forEach((inv) => {
+    const status = inv.success ? "\x1B[38;2;244;140;6m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    const date = new Date(inv.invoked_at * 1e3).toISOString().replace("T", " ").slice(0, 19);
+    console.log(
+      `  ${status}  ${chalk9.gray(date)}  ${inv.duration_ms}ms  ${chalk9.gray(`[${inv.trigger_type}]`)}`
+    );
+  });
+  console.log("");
+}
+async function functionsDelete(slug) {
+  const client = getClient();
+  const spinner2 = ora(`Deleting ${slug}...`).start();
+  const result = await client.code.deleteFunction(slug);
+  if (!result.success) {
+    spinner2.fail(`Delete failed for ${slug}`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  spinner2.succeed(`Deleted ${slug}`);
+}
+async function functionsToggle(slug, active) {
+  const client = getClient();
+  const spinner2 = ora(
+    `${active ? "Enabling" : "Disabling"} ${slug}...`
+  ).start();
+  const result = await client.code.toggleFunction(slug, active);
+  if (!result.success) {
+    spinner2.fail(`Toggle failed for ${slug}`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  spinner2.succeed(`${slug} is now ${active ? "active" : "inactive"}`);
+}
+
+// src/index.ts
+var version4 = getCliVersion();
+var program = new Command();
+program.name("globio").description("The official Globio CLI").version(version4).addHelpText("beforeAll", () => {
+  printBanner(version4);
+  return "";
+});
+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);
+var 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);
+var 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));
+var 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);
+if (process.argv.length <= 2) {
+  printBanner(version4);
+  program.help();
+}
+await program.parseAsync();

package/jsr.json

@@ -0,0 +1,6 @@
+{
+  "name": "@globio/cli",
+  "version": "0.1.1",
+  "license": "MIT",
+  "exports": "./src/index.ts"
+}

package/package.json

@@ -1,10 +1,38 @@
 {
   "name": "@globio/cli",
-  "version": "0.0.1",
-  "description": "The official Globio CLI",
+  "version": "0.1.1",
+  "description": "The official CLI for Globio — game backend as a service",
+  "type": "module",
+  "license": "MIT",
   "bin": {
     "globio": "./dist/index.js"
   },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --out-dir dist --clean",
+    "dev": "tsup src/index.ts --format esm --out-dir dist --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.0",
+    "@globio/sdk": "^1.0.0",
+    "chalk": "^5.3.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^12.0.0",
+    "conf": "^13.0.0",
+    "figlet": "^1.11.0",
+    "firebase-admin": "^12.0.0",
+    "gradient-string": "^3.0.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.0",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
   "publishConfig": {
     "access": "public"
   }