@globio/cli 0.1.8 → 0.2.0

package/src/commands/services.ts

@@ -1,30 +1,70 @@
-import chalk from 'chalk';
 import { config } from '../lib/config.js';
+import { manageRequest, type ManageProjectServices } from '../lib/manage.js';
+import {
+  footer,
+  getCliVersion,
+  green,
+  header,
+  inactive,
+  muted,
+  orange,
+  renderTable,
+} from '../lib/banner.js';
 
-const ALL_SERVICES = [
-  'id',
-  'doc',
-  'vault',
-  'pulse',
-  'scope',
-  'sync',
-  'signal',
-  'mart',
-  'brain',
-  'code',
-];
+const version = getCliVersion();
+
+const SERVICE_DESCRIPTIONS: Record<string, string> = {
+  id: 'Authentication and user management',
+  doc: 'Document database',
+  vault: 'File storage',
+  pulse: 'Feature flags and remote config',
+  scope: 'Analytics and event tracking',
+  sync: 'Real-time multiplayer rooms',
+  signal: 'Push notifications',
+  mart: 'Game economy and payments',
+  brain: 'AI agents and LLM routing',
+  code: 'Edge functions and GC Hooks',
+};
 
 export async function servicesList(options: { profile?: string } = {}) {
-  void options.profile;
-  void config;
-  console.log('');
-  console.log(chalk.cyan('Available Globio services:'));
-  ALL_SERVICES.forEach((service) => {
-    console.log('  ' + chalk.white(service));
+  const profileName = options.profile ?? config.getActiveProfile() ?? 'default';
+  const profile = config.getProfile(profileName);
+  let serviceStatuses: ManageProjectServices = {};
+
+  if (profile?.active_project_id) {
+    try {
+      serviceStatuses = await manageRequest<ManageProjectServices>(
+        `/projects/${profile.active_project_id}/services`,
+        { profileName }
+      );
+    } catch {
+      serviceStatuses = {};
+    }
+  }
+
+  const rows = Object.entries(SERVICE_DESCRIPTIONS).map(([slug, desc]) => {
+    const enabled = serviceStatuses[slug] ?? null;
+    return [
+      orange(slug),
+      muted(desc),
+      enabled === true
+        ? green('enabled')
+        : enabled === false
+          ? inactive('disabled')
+          : inactive('—'),
+    ];
   });
-  console.log('');
+
+  console.log(header(version));
   console.log(
-    chalk.gray('Manage service access via console.globio.stanlink.online')
+    renderTable({
+      columns: [
+        { header: 'Service', width: 10 },
+        { header: 'Description', width: 42 },
+        { header: 'Status', width: 10 },
+      ],
+      rows,
+    })
   );
-  console.log('');
+  console.log(footer('Manage services at console.globio.stanlink.online'));
 }

package/src/commands/watch.ts

@@ -0,0 +1,173 @@
+import { config } from '../lib/config.js';
+import {
+  dim,
+  failure,
+  getCliVersion,
+  green,
+  header,
+  muted,
+  orange,
+  reset,
+} from '../lib/banner.js';
+
+const BASE_URL = 'https://api.globio.stanlink.online';
+const version = getCliVersion();
+
+export async function functionsWatch(
+  slug: string,
+  options: { profile?: string } = {}
+) {
+  const profileName = options.profile ?? config.getActiveProfile();
+  const profile = config.getProfile(profileName ?? 'default');
+
+  if (!profile?.project_api_key) {
+    console.log(
+      failure('No active project.') +
+        reset +
+        ' Run: globio projects use <id>'
+    );
+    process.exit(1);
+  }
+
+  console.log(header(version));
+  console.log(
+    '  ' +
+      orange('watching') +
+      reset +
+      ' ' +
+      slug +
+      dim(' · press Ctrl+C to stop') +
+      '\n'
+  );
+
+  const res = await fetch(`${BASE_URL}/code/functions/${slug}/watch`, {
+    headers: {
+      'X-Globio-Key': profile.project_api_key,
+      Accept: 'text/event-stream',
+    },
+  });
+
+  if (!res.ok || !res.body) {
+    console.log(failure('Failed to connect to watch stream.') + reset);
+    process.exit(1);
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  process.on('SIGINT', () => {
+    console.log('\n' + dim('  Stream closed.') + '\n');
+    void reader.cancel();
+    process.exit(0);
+  });
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const chunks = buffer.split('\n\n');
+    buffer = chunks.pop() ?? '';
+
+    for (const chunk of chunks) {
+      const dataLine = chunk
+        .split('\n')
+        .find((line) => line.startsWith('data: '));
+
+      if (!dataLine) continue;
+
+      try {
+        renderEvent(JSON.parse(dataLine.slice(6)) as WatchEvent);
+      } catch {
+        // Ignore malformed events.
+      }
+    }
+  }
+}
+
+interface WatchEvent {
+  type: 'connected' | 'heartbeat' | 'timeout' | 'invocation';
+  invoked_at?: number;
+  trigger_type?: string;
+  duration_ms?: number;
+  success?: boolean;
+  input?: string | null;
+  result?: string | null;
+  error_message?: string | null;
+  logs?: string | null;
+}
+
+function renderEvent(event: WatchEvent) {
+  if (event.type === 'connected') {
+    console.log(
+      '  ' + green('●') + reset + dim(' connected — waiting for invocations...\n')
+    );
+    return;
+  }
+
+  if (event.type === 'heartbeat') {
+    return;
+  }
+
+  if (event.type === 'timeout') {
+    console.log(
+      '\n' + dim('  Session timed out after 5 minutes.') + ' Run again to resume.\n'
+    );
+    return;
+  }
+
+  if (event.type !== 'invocation' || !event.invoked_at) {
+    return;
+  }
+
+  const time = new Date(event.invoked_at * 1000)
+    .toISOString()
+    .replace('T', ' ')
+    .slice(0, 19);
+
+  const status = event.success ? green('✓') : failure('✗');
+  const trigger = dim(`[${event.trigger_type ?? 'http'}]`);
+  const duration = dim(`${event.duration_ms ?? 0}ms`);
+
+  console.log(
+    '  ' + status + reset + ' ' + dim(time) + '  ' + trigger + '  ' + duration
+  );
+
+  if (event.input && event.input !== '{}') {
+    try {
+      console.log(
+        '  ' + dim('  input   ') + muted(JSON.stringify(JSON.parse(event.input)))
+      );
+    } catch {
+      // Ignore invalid JSON payloads.
+    }
+  }
+
+  if (event.logs) {
+    try {
+      const logs = JSON.parse(event.logs) as string[];
+      for (const line of logs) {
+        console.log('  ' + dim('  log     ') + reset + line);
+      }
+    } catch {
+      // Ignore invalid log payloads.
+    }
+  }
+
+  if (event.result && event.result !== 'null') {
+    try {
+      console.log(
+        '  ' + dim('  result  ') + muted(JSON.stringify(JSON.parse(event.result)))
+      );
+    } catch {
+      // Ignore invalid result payloads.
+    }
+  }
+
+  if (event.error_message) {
+    console.log('  ' + dim('  error   ') + failure(event.error_message) + reset);
+  }
+
+  console.log('');
+}

package/src/index.ts

@@ -17,6 +17,7 @@ import {
   functionsDelete,
   functionsToggle,
 } from './commands/functions.js';
+import { functionsWatch } from './commands/watch.js';
 import {
   migrateFirestore,
   migrateFirebaseStorage,
@@ -106,6 +107,11 @@ functions
   .option('-l, --limit <n>', 'Number of entries', '20')
   .option('--profile <name>', 'Use a specific profile')
   .action(functionsLogs);
+functions
+  .command('watch <slug>')
+  .description('Stream live function execution logs')
+  .option('--profile <name>', 'Use a specific profile')
+  .action(functionsWatch);
 functions.command('delete <slug>').description('Delete a function').option('--profile <name>', 'Use a specific profile').action(functionsDelete);
 functions
   .command('enable <slug>')

package/src/lib/banner.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from 'fs';
 import figlet from 'figlet';
 import gradientString from 'gradient-string';
+export * from './table.js';
 
 const globioGradient = gradientString(
   '#e85d04',
@@ -39,12 +40,6 @@ export function printInfo(message: string) {
   console.log('\x1b[2m›\x1b[0m  ' + message);
 }
 
-export const orange = (s: string) => '\x1b[38;2;244;140;6m' + s + '\x1b[0m';
-
-export const gold = (s: string) => '\x1b[38;2;255;208;0m' + s + '\x1b[0m';
-
-export const muted = (s: string) => '\x1b[2m' + s + '\x1b[0m';
-
 export function getCliVersion() {
   const file = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
   return (JSON.parse(file) as { version: string }).version;

package/src/lib/config.ts

@@ -11,6 +11,7 @@ export interface ProfileData {
   pat: string;
   account_email: string;
   account_name: string;
+  org_name?: string;
   active_project_id?: string;
   active_project_name?: string;
   project_api_key?: string;
@@ -88,6 +89,7 @@ export const config = {
       pat: data.pat ?? existing?.pat ?? '',
       account_email: data.account_email ?? existing?.account_email ?? '',
       account_name: data.account_name ?? existing?.account_name ?? '',
+      org_name: data.org_name ?? existing?.org_name,
       active_project_id: data.active_project_id ?? existing?.active_project_id,
       active_project_name: data.active_project_name ?? existing?.active_project_name,
       project_api_key: data.project_api_key ?? existing?.project_api_key,

package/src/lib/manage.ts

@@ -36,6 +36,10 @@ export interface ManageProject {
   active: boolean;
 }
 
+export interface ManageProjectServices {
+  [key: string]: boolean;
+}
+
 export interface ManageProjectKey {
   id: string;
   name: string;

package/src/lib/table.ts

@@ -0,0 +1,97 @@
+export interface Column {
+  header: string;
+  width: number;
+  color?: (val: string) => string;
+}
+
+export interface TableOptions {
+  columns: Column[];
+  rows: string[][];
+}
+
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+
+export const orange = (s: string) => '\x1b[38;2;244;140;6m' + s;
+export const gold = (s: string) => '\x1b[38;2;255;208;0m' + s;
+export const dim = (s: string) => '\x1b[2m' + s + '\x1b[0m';
+export const white = (s: string) => '\x1b[97m' + s;
+export const green = (s: string) => '\x1b[38;2;34;197;94m' + s;
+export const muted = (s: string) => '\x1b[38;2;85;85;85m' + s;
+export const inactive = (s: string) => '\x1b[38;2;68;68;68m' + s;
+export const failure = (s: string) => '\x1b[38;2;232;93;4m' + s;
+export const reset = '\x1b[0m';
+
+function stripAnsi(value: string): string {
+  return value.replace(ANSI_PATTERN, '');
+}
+
+function fitCell(value: string, width: number): string {
+  const plain = stripAnsi(value);
+  if (plain.length <= width) {
+    return value + ' '.repeat(width - plain.length);
+  }
+
+  const truncated = plain.slice(0, width);
+  return truncated;
+}
+
+export function renderTable(options: TableOptions): string {
+  const { columns, rows } = options;
+  const lines: string[] = [];
+
+  lines.push(
+    '  ┌' + columns.map((c) => '─'.repeat(c.width + 2)).join('┬') + '┐'
+  );
+
+  lines.push(
+    '  │' +
+      columns
+        .map((c) => ' ' + dim(c.header.padEnd(c.width)) + ' │')
+        .join('')
+  );
+
+  lines.push(
+    '  ├' + columns.map((c) => '─'.repeat(c.width + 2)).join('┼') + '┤'
+  );
+
+  for (const row of rows) {
+    lines.push(
+      '  │' +
+        columns
+          .map((c, i) => {
+            const raw = row[i] ?? '';
+            const fitted = fitCell(raw, c.width);
+            const colored = c.color
+              ? fitCell(c.color(stripAnsi(raw)), c.width)
+              : fitted;
+            return ' ' + colored + ' ' + reset + '│';
+          })
+          .join('')
+    );
+  }
+
+  lines.push(
+    '  └' + columns.map((c) => '─'.repeat(c.width + 2)).join('┴') + '┘'
+  );
+
+  return lines.join('\n');
+}
+
+export function header(version: string, subtitle?: string): string {
+  const lines = [
+    '',
+    orange('  ⇒⇒') + reset + ' globio ' + dim(version),
+    dim('  ──────────────────────────────────────────'),
+  ];
+
+  if (subtitle) {
+    lines.push('  ' + subtitle);
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+export function footer(text: string): string {
+  return '\n' + dim('  ' + text) + '\n';
+}