@globio/cli 0.2.0 → 0.2.3

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@globio/cli",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "The official CLI for Globio — game backend as a service",
   "type": "module",
   "license": "MIT",
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.0",
-    "@globio/sdk": "^1.0.0",
+    "@globio/sdk": "^1.1.0",
     "chalk": "^5.3.0",
     "cli-progress": "^3.12.0",
     "commander": "^12.0.0",

package/src/auth/login.ts

@@ -2,7 +2,7 @@ import * as p from '@clack/prompts';
 import { exec } from 'child_process';
 import { config } from '../lib/config.js';
 import { getConsoleCliAuthUrl, manageRequest, type ManageAccount } from '../lib/manage.js';
-import { failure, getCliVersion, muted, orange, printBanner, white } from '../lib/banner.js';
+import { failure, getCliVersion, jsonOutput, muted, orange, printBanner, white } from '../lib/banner.js';
 
 const version = getCliVersion();
 
@@ -25,6 +25,19 @@ async function savePat(token: string) {
   return account;
 }
 
+function storeProfile(profileName: string, token: string, account: ManageAccount) {
+  const hadProfiles = config.listProfiles().length > 0;
+  config.setProfile(profileName, {
+    pat: token,
+    account_email: account.email,
+    account_name: account.display_name ?? account.email,
+    created_at: Date.now(),
+  });
+  if (profileName === 'default' || !hadProfiles) {
+    config.setActiveProfile(profileName);
+  }
+}
+
 function warnOnDuplicateAccount(accountEmail: string, targetProfileName: string) {
   const allProfiles = config.listProfiles();
   const duplicate = allProfiles.find((name) => {
@@ -45,8 +58,30 @@ function warnOnDuplicateAccount(accountEmail: string, targetProfileName: string)
   console.log('');
 }
 
-async function runTokenLogin(profileName: string) {
-  const hadProfiles = config.listProfiles().length > 0;
+async function completeTokenLogin(
+  token: string,
+  profileName: string,
+  json = false
+) {
+  const account = await savePat(token);
+  if (!json) {
+    warnOnDuplicateAccount(account.email, profileName);
+  }
+  storeProfile(profileName, token, account);
+
+  if (json) {
+    jsonOutput({
+      success: true,
+      email: account.email,
+      name: account.display_name ?? account.email,
+      profile: profileName,
+    });
+  }
+
+  return account;
+}
+
+async function runTokenLogin(profileName: string, json = false) {
   const token = await p.text({
     message: 'Paste your personal access token',
     placeholder: 'glo_pat_...',
@@ -65,17 +100,7 @@ async function runTokenLogin(profileName: string) {
   const spinner = p.spinner();
   spinner.start('Validating personal access token...');
   try {
-    const account = await savePat(token);
-    warnOnDuplicateAccount(account.email, profileName);
-    config.setProfile(profileName, {
-      pat: token,
-      account_email: account.email,
-      account_name: account.display_name ?? account.email,
-      created_at: Date.now(),
-    });
-    if (profileName === 'default' || !hadProfiles) {
-      config.setActiveProfile(profileName);
-    }
+    const account = await completeTokenLogin(token, profileName, json);
     spinner.stop('Token validated.');
     p.outro(`Logged in as ${account.email}\nProfile: ${profileName}`);
   } catch (error) {
@@ -85,10 +110,9 @@ async function runTokenLogin(profileName: string) {
   }
 }
 
-async function runBrowserLogin(profileName: string) {
+async function runBrowserLogin(profileName: string, json = false) {
   const state = crypto.randomUUID();
   const spinner = p.spinner();
-  const hadProfiles = config.listProfiles().length > 0;
 
   await manageRequest('/cli-auth/request', {
     method: 'POST',
@@ -124,17 +148,28 @@ async function runBrowserLogin(profileName: string) {
           body: { code: status.code },
         });
 
-        warnOnDuplicateAccount(exchange.account.email, profileName);
+        if (!json) {
+          warnOnDuplicateAccount(exchange.account.email, profileName);
+        }
         config.setProfile(profileName, {
           pat: exchange.token,
           account_email: exchange.account.email,
           account_name: exchange.account.display_name ?? exchange.account.email,
           created_at: Date.now(),
         });
-        if (profileName === 'default' || !hadProfiles) {
+        if (profileName === 'default' || config.listProfiles().length === 1) {
           config.setActiveProfile(profileName);
         }
 
+        if (json) {
+          jsonOutput({
+            success: true,
+            email: exchange.account.email,
+            name: exchange.account.display_name ?? exchange.account.email,
+            profile: profileName,
+          });
+        }
+
         spinner.stop('Browser approval received.');
         p.outro(`Logged in as ${exchange.account.email}\nProfile: ${profileName}`);
         return;
@@ -151,11 +186,40 @@ async function runBrowserLogin(profileName: string) {
   process.exit(1);
 }
 
-export async function login(options: { token?: boolean; profile?: string } = {}) {
-  printBanner(version);
+export async function login(
+  options: { token?: string; profile?: string; json?: boolean } = {}
+) {
   const profileName = options.profile ?? 'default';
   const existing = config.getProfile(profileName);
 
+  if (options.token) {
+    try {
+      const account = await completeTokenLogin(options.token, profileName, options.json);
+      if (!options.json) {
+        console.log(`Logged in as ${account.email}\nProfile: ${profileName}`);
+      }
+      return;
+    } catch (error) {
+      if (options.json) {
+        jsonOutput({
+          success: false,
+          error: error instanceof Error ? error.message : 'Could not validate token',
+        });
+      }
+      console.log(failure(error instanceof Error ? error.message : 'Could not validate token'));
+      process.exit(1);
+    }
+  }
+
+  if (options.json) {
+    jsonOutput({
+      success: false,
+      error: 'login --json requires --token <pat>',
+    });
+  }
+
+  printBanner(version);
+
   if (existing) {
     const proceed = await p.confirm({
       message: `Already logged in as ${existing.account_email} on profile "${profileName}". Replace?`,
@@ -168,11 +232,6 @@ export async function login(options: { token?: boolean; profile?: string } = {})
     }
   }
 
-  if (options.token) {
-    await runTokenLogin(profileName);
-    return;
-  }
-
   const choice = await p.select({
     message: 'Choose a login method',
     options: [
@@ -187,12 +246,12 @@ export async function login(options: { token?: boolean; profile?: string } = {})
   }
 
   if (choice === 'token') {
-    await runTokenLogin(profileName);
+    await runTokenLogin(profileName, options.json);
     return;
   }
 
   try {
-    await runBrowserLogin(profileName);
+    await runBrowserLogin(profileName, options.json);
   } catch (error) {
     p.outro(failure(error instanceof Error ? error.message : 'Could not connect to Globio.') + '\x1b[0m');
     process.exit(1);

package/src/auth/whoami.ts

@@ -4,6 +4,7 @@ import {
   getCliVersion,
   header,
   inactive,
+  jsonOutput,
   muted,
   orange,
   renderTable,
@@ -14,11 +15,24 @@ import {
 
 const version = getCliVersion();
 
-export async function whoami(options: { profile?: string } = {}) {
+export async function whoami(options: { profile?: string; json?: boolean } = {}) {
   const profileName = options.profile ?? config.getActiveProfile() ?? 'default';
   const profile = config.getProfile(profileName);
+  const active = config.getActiveProfile();
 
   if (!profile) {
+    if (options.json) {
+      jsonOutput({
+        profile: profileName,
+        active: false,
+        account_email: null,
+        account_name: null,
+        org_name: null,
+        active_project_id: null,
+        active_project_name: null,
+      });
+    }
+
     console.log(
       header(version) +
         '  ' +
@@ -29,8 +43,19 @@ export async function whoami(options: { profile?: string } = {}) {
     return;
   }
 
+  if (options.json) {
+    jsonOutput({
+      profile: profileName,
+      active: profileName === active,
+      account_email: profile.account_email,
+      account_name: profile.account_name,
+      org_name: profile.org_name ?? null,
+      active_project_id: profile.active_project_id ?? null,
+      active_project_name: profile.active_project_name ?? null,
+    });
+  }
+
   const allProfiles = config.listProfiles();
-  const active = config.getActiveProfile();
   const otherProfiles = allProfiles.filter((p) => p !== profileName).join(', ') || '—';
 
   console.log(

package/src/commands/functions.ts

@@ -8,6 +8,7 @@ import {
   green,
   header,
   inactive,
+  jsonOutput,
   muted,
   orange,
   gold,
@@ -21,11 +22,33 @@ function resolveProfileName(profile?: string) {
   return profile ?? config.getActiveProfile() ?? 'default';
 }
 
-export async function functionsList(options: { profile?: string } = {}) {
+function parseJsonField<T>(value: string | null | undefined): T | null {
+  if (!value) return null;
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return null;
+  }
+}
+
+export async function functionsList(options: { profile?: string; json?: boolean } = {}) {
   const profileName = resolveProfileName(options.profile);
   const client = getClient(profileName);
   const result = await client.code.listFunctions();
 
+  if (options.json) {
+    jsonOutput(
+      result.success
+        ? result.data.map((fn: CodeFunction) => ({
+            slug: fn.slug,
+            type: fn.type,
+            trigger_event: fn.trigger_event,
+            active: fn.active,
+          }))
+        : []
+    );
+  }
+
   if (!result.success || !result.data.length) {
     console.log(header(version) + '  ' + muted('No functions found.') + '\n');
     return;
@@ -53,9 +76,15 @@ export async function functionsList(options: { profile?: string } = {}) {
   console.log('');
 }
 
-export async function functionsCreate(slug: string, _options: { profile?: string } = {}) {
+export async function functionsCreate(
+  slug: string,
+  options: { profile?: string; json?: boolean } = {}
+) {
   const filename = `${slug}.js`;
   if (existsSync(filename)) {
+    if (options.json) {
+      jsonOutput({ success: false, file: filename, error: 'File already exists' });
+    }
     console.log(inactive(`${filename} already exists.`));
     return;
   }
@@ -76,13 +105,16 @@ async function handler(input, globio) {
 }
 `;
   writeFileSync(filename, template);
+  if (options.json) {
+    jsonOutput({ success: true, file: filename });
+  }
   console.log(green(`Created ${filename}`));
   console.log(muted(`Deploy with: npx @globio/cli functions deploy ${slug}`));
 }
 
 export async function functionsDeploy(
   slug: string,
-  options: { file?: string; name?: string; profile?: string }
+  options: { file?: string; name?: string; profile?: string; json?: boolean }
 ) {
   const filename = options.file ?? `${slug}.js`;
   if (!existsSync(filename)) {
@@ -97,8 +129,8 @@ export async function functionsDeploy(
   const code = readFileSync(filename, 'utf-8');
   const profileName = resolveProfileName(options.profile);
   const client = getClient(profileName);
-  const spinner = ora(`Deploying ${slug}...`).start();
   const existing = await client.code.getFunction(slug);
+  const spinner = options.json ? null : ora(`Deploying ${slug}...`).start();
 
   let result;
   if (existing.success) {
@@ -116,17 +148,28 @@ export async function functionsDeploy(
   }
 
   if (!result.success) {
-    spinner.fail('Deploy failed');
+    if (options.json) {
+      jsonOutput({ success: false, error: result.error.message });
+    }
+    spinner?.fail('Deploy failed');
     console.error(result.error.message);
     process.exit(1);
   }
 
-  spinner.succeed(existing.success ? `Updated ${slug}` : `Deployed ${slug}`);
+  if (options.json) {
+    jsonOutput({
+      success: true,
+      slug,
+      action: existing.success ? 'updated' : 'created',
+    });
+  }
+
+  spinner?.succeed(existing.success ? `Updated ${slug}` : `Deployed ${slug}`);
 }
 
 export async function functionsInvoke(
   slug: string,
-  options: { input?: string; profile?: string }
+  options: { input?: string; profile?: string; json?: boolean }
 ) {
   let input: Record<string, unknown> = {};
   if (options.input) {
@@ -140,16 +183,26 @@ export async function functionsInvoke(
 
   const profileName = resolveProfileName(options.profile);
   const client = getClient(profileName);
-  const spinner = ora(`Invoking ${slug}...`).start();
+  const spinner = options.json ? null : ora(`Invoking ${slug}...`).start();
   const result = await client.code.invoke(slug, input);
-  spinner.stop();
+  spinner?.stop();
 
   if (!result.success) {
+    if (options.json) {
+      jsonOutput({ success: false, error: result.error.message });
+    }
     console.log(failure('Invocation failed'));
     console.error(result.error.message);
     return;
   }
 
+  if (options.json) {
+    jsonOutput({
+      result: result.data.result,
+      duration_ms: result.data.duration_ms,
+    });
+  }
+
   console.log('');
   console.log(orange('Result:'));
   console.log(JSON.stringify(result.data.result, null, 2));
@@ -158,13 +211,36 @@ export async function functionsInvoke(
 
 export async function functionsLogs(
   slug: string,
-  options: { limit?: string; profile?: string }
+  options: { limit?: string; profile?: string; json?: boolean }
 ) {
   const limit = options.limit ? parseInt(options.limit, 10) : 20;
   const profileName = resolveProfileName(options.profile);
   const client = getClient(profileName);
   const result = await client.code.getInvocations(slug, limit);
 
+  if (options.json) {
+    jsonOutput(
+      result.success
+        ? (result.data as Array<CodeInvocation & {
+            logs?: string | null;
+            error_message?: string | null;
+            input?: string | null;
+            result?: string | null;
+          }>).map((invocation) => ({
+            id: invocation.id,
+            trigger_type: invocation.trigger_type,
+            duration_ms: invocation.duration_ms,
+            success: invocation.success,
+            invoked_at: invocation.invoked_at,
+            logs: parseJsonField<string[]>(invocation.logs) ?? [],
+            error_message: invocation.error_message ?? null,
+            input: parseJsonField<Record<string, unknown>>(invocation.input),
+            result: parseJsonField<unknown>(invocation.result),
+          }))
+        : []
+    );
+  }
+
   if (!result.success || !result.data.length) {
     console.log(header(version) + '  ' + muted('No invocations yet.') + '\n');
     return;
@@ -198,34 +274,49 @@ export async function functionsLogs(
   console.log('');
 }
 
-export async function functionsDelete(slug: string, options: { profile?: string } = {}) {
+export async function functionsDelete(
+  slug: string,
+  options: { profile?: string; json?: boolean } = {}
+) {
   const profileName = resolveProfileName(options.profile);
   const client = getClient(profileName);
-  const spinner = ora(`Deleting ${slug}...`).start();
+  const spinner = options.json ? null : ora(`Deleting ${slug}...`).start();
   const result = await client.code.deleteFunction(slug);
   if (!result.success) {
-    spinner.fail(`Delete failed for ${slug}`);
+    if (options.json) {
+      jsonOutput({ success: false, error: result.error.message });
+    }
+    spinner?.fail(`Delete failed for ${slug}`);
     console.error(result.error.message);
     process.exit(1);
   }
-  spinner.succeed(`Deleted ${slug}`);
+  if (options.json) {
+    jsonOutput({ success: true, slug });
+  }
+  spinner?.succeed(`Deleted ${slug}`);
 }
 
 export async function functionsToggle(
   slug: string,
   active: boolean,
-  options: { profile?: string } = {}
+  options: { profile?: string; json?: boolean } = {}
 ) {
   const profileName = resolveProfileName(options.profile);
   const client = getClient(profileName);
-  const spinner = ora(
-    `${active ? 'Enabling' : 'Disabling'} ${slug}...`
-  ).start();
+  const spinner = options.json
+    ? null
+    : ora(`${active ? 'Enabling' : 'Disabling'} ${slug}...`).start();
   const result = await client.code.toggleFunction(slug, active);
   if (!result.success) {
-    spinner.fail(`Toggle failed for ${slug}`);
+    if (options.json) {
+      jsonOutput({ success: false, error: result.error.message });
+    }
+    spinner?.fail(`Toggle failed for ${slug}`);
     console.error(result.error.message);
     process.exit(1);
   }
-  spinner.succeed(`${slug} is now ${active ? 'active' : 'inactive'}`);
+  if (options.json) {
+    jsonOutput({ success: true, slug, active });
+  }
+  spinner?.succeed(`${slug} is now ${active ? 'active' : 'inactive'}`);
 }