@globio/cli 0.1.2 → 0.1.4

package/src/commands/projects.ts

@@ -1,16 +1,181 @@
+import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { config } from '../lib/config.js';
+import {
+  manageRequest,
+  type ManageOrg,
+  type ManageProject,
+  type ManageProjectKey,
+} from '../lib/manage.js';
+
+function slugify(value: string) {
+  return value
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\\s-]/g, '')
+    .replace(/\\s+/g, '-')
+    .replace(/-+/g, '-');
+}
+
+function resolveProfileName(profileName?: string) {
+  return profileName ?? config.getActiveProfile() ?? 'default';
+}
+
+async function createServerKey(projectId: string, profileName: string) {
+  const created = await manageRequest<ManageProjectKey>(`/projects/${projectId}/keys`, {
+    method: 'POST',
+    body: {
+      name: 'CLI server key',
+      scope: 'server',
+    },
+    profileName,
+  });
+
+  if (!created.token) {
+    throw new Error('Management API did not return a project API key');
+  }
+
+  return created.token;
+}
+
+export async function projectsList(options: { profile?: string } = {}) {
+  const profileName = resolveProfileName(options.profile);
+  config.requireAuth(profileName);
+
+  const projects = await manageRequest<ManageProject[]>('/projects', { profileName });
+  const activeProjectId = config.getProfile(profileName)?.active_project_id;
+  const grouped = new Map<string, ManageProject[]>();
+
+  for (const project of projects) {
+    const list = grouped.get(project.org_name) ?? [];
+    list.push(project);
+    grouped.set(project.org_name, list);
+  }
 
-export async function projectsList() {
-  const cfg = config.get();
   console.log('');
+  if (!projects.length) {
+    console.log(chalk.gray('No projects found.'));
+    console.log('');
+    return;
+  }
+
+  for (const [orgName, orgProjects] of grouped.entries()) {
+    console.log(chalk.cyan(`org: ${orgName}`));
+    for (const project of orgProjects) {
+      const marker = project.id === activeProjectId ? chalk.green('●') : chalk.gray('○');
+      const active = project.id === activeProjectId ? chalk.green('  (active)') : '';
+      console.log(`  ${marker} ${project.slug.padEnd(22)} ${chalk.gray(project.id)}${active}`);
+    }
+    console.log('');
+  }
+}
+
+export async function projectsUse(projectId: string, options: { profile?: string } = {}) {
+  const profileName = resolveProfileName(options.profile);
+  config.requireAuth(profileName);
+
+  const projects = await manageRequest<ManageProject[]>('/projects', { profileName });
+  const project = projects.find((item) => item.id === projectId);
+  if (!project) {
+    console.log(chalk.red(`Project not found: ${projectId}`));
+    process.exit(1);
+  }
+
+  await manageRequest<ManageProjectKey[]>(`/projects/${projectId}/keys`, { profileName });
+  const apiKey = await createServerKey(projectId, profileName);
+
+  config.setProfile(profileName, {
+    active_project_id: project.id,
+    active_project_name: project.name,
+    project_api_key: apiKey,
+  });
+  config.setActiveProfile(profileName);
+
   console.log(
-    chalk.cyan('Active project: ') + (cfg.projectId ?? chalk.gray('none'))
+    chalk.green('Active project set to: ') + chalk.cyan(`${project.name} (${project.id})`)
   );
-  console.log('');
 }
 
-export async function projectsUse(projectId: string) {
-  config.set({ projectId });
-  console.log(chalk.green('Active project set to: ') + chalk.cyan(projectId));
+export async function projectsCreate(options: { profile?: string } = {}) {
+  const profileName = resolveProfileName(options.profile);
+  config.requireAuth(profileName);
+
+  const orgs = await manageRequest<ManageOrg[]>('/orgs', { profileName });
+  if (!orgs.length) {
+    console.log(chalk.red('No organizations found. Create one in the console first.'));
+    process.exit(1);
+  }
+
+  const orgId = await p.select({
+    message: 'Select an organization',
+    options: orgs.map((org) => ({
+      value: org.id,
+      label: org.name,
+      hint: org.role,
+    })),
+  });
+
+  if (p.isCancel(orgId)) {
+    p.cancel('Project creation cancelled.');
+    process.exit(0);
+  }
+
+  const values = await p.group(
+    {
+      name: () =>
+        p.text({
+          message: 'Project name',
+          validate: (value) => (!value ? 'Project name is required' : undefined),
+        }),
+      slug: ({ results }) =>
+        p.text({
+          message: 'Project slug',
+          initialValue: slugify(String(results.name ?? '')),
+          validate: (value) => (!value ? 'Project slug is required' : undefined),
+        }),
+      environment: () =>
+        p.select({
+          message: 'Environment',
+          options: [
+            { value: 'development', label: 'development' },
+            { value: 'staging', label: 'staging' },
+            { value: 'production', label: 'production' },
+          ],
+        }),
+    },
+    {
+      onCancel: () => {
+        p.cancel('Project creation cancelled.');
+        process.exit(0);
+      },
+    }
+  );
+
+  const result = await manageRequest<{
+    project: { id: string; name: string; slug: string; environment: string; active: boolean };
+    keys: { client: string; server: string };
+  }>('/projects', {
+    method: 'POST',
+    body: {
+      org_id: orgId,
+      name: values.name,
+      slug: values.slug,
+      environment: values.environment,
+    },
+    profileName,
+  });
+
+  config.setProfile(profileName, {
+    active_project_id: result.project.id,
+    active_project_name: result.project.name,
+    project_api_key: result.keys.server,
+  });
+  config.setActiveProfile(profileName);
+
+  console.log('');
+  console.log(chalk.green('Project created successfully.'));
+  console.log(chalk.cyan('Project: ') + `${result.project.name} (${result.project.id})`);
+  console.log(chalk.cyan('Client key: ') + result.keys.client);
+  console.log(chalk.cyan('Server key: ') + result.keys.server);
+  console.log('');
 }

package/src/commands/services.ts

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { config } from '../lib/config.js';
 
 const ALL_SERVICES = [
   'id',
@@ -13,7 +14,9 @@ const ALL_SERVICES = [
   'code',
 ];
 
-export async function servicesList() {
+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) => {

package/src/index.ts

@@ -2,9 +2,10 @@
 import { Command } from 'commander';
 import { login } from './auth/login.js';
 import { logout } from './auth/logout.js';
+import { useProfile } from './auth/useProfile.js';
 import { whoami } from './auth/whoami.js';
 import { init } from './commands/init.js';
-import { projectsList, projectsUse } from './commands/projects.js';
+import { projectsCreate, projectsList, projectsUse } from './commands/projects.js';
 import { servicesList } from './commands/services.js';
 import {
   functionsList,
@@ -32,46 +33,79 @@ program
   .addHelpText('beforeAll', () => {
     printBanner(version);
     return '';
-  });
+  })
+  .addHelpText(
+    'after',
+    `
+Examples:
+  $ globio login
+  $ globio login --profile work
+  $ globio use work
+  $ globio projects list
+  $ globio projects use proj_abc123
+  $ globio functions deploy my-function
+  $ globio migrate firestore --from ./key.json --all
 
-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);
+Credentials are stored in ~/.globio/profiles/
+`
+  );
 
-program.command('init').description('Initialize a Globio project').action(init);
+program
+  .command('login')
+  .description('Log in to your Globio account')
+  .option('-p, --profile <name>', 'Profile name', 'default')
+  .option('--token', 'Use a personal access token')
+  .action(login);
+program.command('logout').description('Log out').option('--profile <name>', 'Use a specific profile').action(logout);
+program.command('whoami').description('Show current account and project').option('--profile <name>', 'Use a specific profile').action(whoami);
+program.command('use <profile>').description('Switch active profile').action(useProfile);
+
+program.command('init').description('Initialize a Globio project').option('--profile <name>', 'Use a specific profile').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);
+projects.command('list').description('List projects').option('--profile <name>', 'Use a specific profile').action(projectsList);
+projects.command('create').description('Create a project').option('--profile <name>', 'Use a specific profile').action(projectsCreate);
+projects.command('use <projectId>').description('Set active project').option('--profile <name>', 'Use a specific profile').action(projectsUse);
 
-program.command('services').description('List available Globio services').action(servicesList);
+program.command('services').description('List available Globio services').option('--profile <name>', 'Use a specific profile').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('list').description('List all functions').option('--profile <name>', 'Use a specific profile').action(functionsList);
+functions.command('create <slug>').description('Scaffold a new function file locally').option('--profile <name>', 'Use a specific profile').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')
+  .option('--profile <name>', 'Use a specific profile')
   .action(functionsDeploy);
 functions
   .command('invoke <slug>')
   .description('Invoke a function')
   .option('-i, --input <json>', 'JSON input payload')
+  .option('--profile <name>', 'Use a specific profile')
   .action(functionsInvoke);
 functions
   .command('logs <slug>')
   .description('Show invocation history')
   .option('-l, --limit <n>', 'Number of entries', '20')
+  .option('--profile <name>', 'Use a specific profile')
   .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));
+functions.command('delete <slug>').description('Delete a function').option('--profile <name>', 'Use a specific profile').action(functionsDelete);
+functions
+  .command('enable <slug>')
+  .description('Enable a function')
+  .option('--profile <name>', 'Use a specific profile')
+  .action((slug, options) => functionsToggle(slug, true, options));
+functions
+  .command('disable <slug>')
+  .description('Disable a function')
+  .option('--profile <name>', 'Use a specific profile')
+  .action((slug, options) => functionsToggle(slug, false, options));
 
 const migrate = program
   .command('migrate')
@@ -83,6 +117,7 @@ migrate
   .requiredOption('--from <path>', 'Path to Firebase service account JSON')
   .option('--collection <name>', 'Migrate a specific collection')
   .option('--all', 'Migrate all collections')
+  .option('--profile <name>', 'Use a specific profile')
   .action(migrateFirestore);
 
 migrate
@@ -92,10 +127,18 @@ migrate
   .requiredOption('--bucket <name>', 'Firebase Storage bucket')
   .option('--folder <path>', 'Migrate a specific folder')
   .option('--all', 'Migrate all files')
+  .option('--profile <name>', 'Use a specific profile')
   .action(migrateFirebaseStorage);
 
-if (process.argv.length <= 2) {
-  program.help();
+async function main() {
+  if (process.argv.length <= 2) {
+    program.help();
+  }
+
+  await program.parseAsync();
 }
 
-await program.parseAsync();
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/src/lib/config.ts

@@ -1,47 +1,139 @@
 import chalk from 'chalk';
-import Conf from 'conf';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import os from 'os';
+import path from 'path';
 
-interface GlobioConfig {
-  apiKey?: string;
-  projectId?: string;
-  projectName?: string;
-  email?: string;
+interface GlobalConfig {
+  active_profile: string;
 }
 
-const store = new Conf<GlobioConfig>({
-  projectName: 'globio',
-  defaults: {},
-});
+export interface ProfileData {
+  pat: string;
+  account_email: string;
+  account_name: string;
+  active_project_id?: string;
+  active_project_name?: string;
+  project_api_key?: string;
+  created_at: number;
+}
+
+const baseDir = path.join(os.homedir(), '.globio');
+const profilesDir = path.join(baseDir, 'profiles');
+const configPath = path.join(baseDir, 'config.json');
+
+function ensureBaseDir() {
+  mkdirSync(baseDir, { recursive: true });
+}
+
+function ensureProfilesDir() {
+  ensureBaseDir();
+  mkdirSync(profilesDir, { recursive: true });
+}
+
+function readGlobalConfig(): GlobalConfig {
+  if (!existsSync(configPath)) {
+    return { active_profile: 'default' };
+  }
+
+  try {
+    const raw = JSON.parse(readFileSync(configPath, 'utf-8')) as Partial<GlobalConfig>;
+    return {
+      active_profile: raw.active_profile ?? 'default',
+    };
+  } catch {
+    return { active_profile: 'default' };
+  }
+}
+
+function writeGlobalConfig(data: GlobalConfig) {
+  ensureBaseDir();
+  writeFileSync(configPath, JSON.stringify(data, null, 2) + '\n');
+}
+
+function profilePath(name: string) {
+  return path.join(profilesDir, `${name}.json`);
+}
+
+function readProfile(name: string): ProfileData | null {
+  const file = profilePath(name);
+  if (!existsSync(file)) return null;
+
+  try {
+    return JSON.parse(readFileSync(file, 'utf-8')) as ProfileData;
+  } catch {
+    return null;
+  }
+}
+
+function writeProfile(name: string, data: ProfileData) {
+  ensureProfilesDir();
+  writeFileSync(profilePath(name), JSON.stringify(data, null, 2) + '\n');
+}
 
 export const config = {
-  get: (): GlobioConfig => store.store,
-  set: (values: Partial<GlobioConfig>) => {
-    Object.entries(values).forEach(([key, value]) => {
-      if (value !== undefined) {
-        store.set(key as keyof GlobioConfig, value);
-      }
-    });
-  },
-  clear: () => store.clear(),
-  getApiKey: () => store.get('apiKey'),
-  requireAuth: () => {
-    const key = store.get('apiKey');
-    if (!key) {
+  getBaseDir: () => baseDir,
+  getProfilesDir: () => profilesDir,
+  getActiveProfile: (): string => readGlobalConfig().active_profile,
+  setActiveProfile: (name: string): void => {
+    writeGlobalConfig({ active_profile: name });
+  },
+  getProfile: (name?: string): ProfileData | null => {
+    const profileName = name ?? config.getActiveProfile();
+    if (!profileName) return null;
+    return readProfile(profileName);
+  },
+  setProfile: (name: string, data: Partial<ProfileData>): void => {
+    const existing = readProfile(name);
+    const next: ProfileData = {
+      pat: data.pat ?? existing?.pat ?? '',
+      account_email: data.account_email ?? existing?.account_email ?? '',
+      account_name: data.account_name ?? existing?.account_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,
+      created_at: data.created_at ?? existing?.created_at ?? Date.now(),
+    };
+    writeProfile(name, next);
+  },
+  deleteProfile: (name: string): void => {
+    const file = profilePath(name);
+    if (existsSync(file)) {
+      rmSync(file);
+    }
+  },
+  listProfiles: (): string[] => {
+    if (!existsSync(profilesDir)) return [];
+    return readdirSync(profilesDir)
+      .filter((file) => file.endsWith('.json'))
+      .map((file) => file.replace(/\.json$/, ''))
+      .sort();
+  },
+  getActiveProfileData: (): ProfileData | null => {
+    const active = config.getActiveProfile();
+    if (!active) return null;
+    return config.getProfile(active);
+  },
+  requireAuth: (profileName?: string): { pat: string; profileName: string } => {
+    const resolvedProfile = profileName ?? config.getActiveProfile() ?? 'default';
+    const profile = config.getProfile(resolvedProfile);
+    if (!profile?.pat) {
       console.error(chalk.red('Not logged in. Run: npx @globio/cli login'));
       process.exit(1);
     }
-    return key;
+    return { pat: profile.pat, profileName: resolvedProfile };
   },
-  requireProject: () => {
-    const projectId = store.get('projectId');
-    if (!projectId) {
+  requireProject: (profileName?: string): { projectId: string; projectName: string } => {
+    const resolvedProfile = profileName ?? config.getActiveProfile() ?? 'default';
+    const profile = config.getProfile(resolvedProfile);
+    if (!profile?.active_project_id) {
       console.error(
         chalk.red('No active project. Run: npx @globio/cli projects use <projectId>')
       );
       process.exit(1);
     }
-    return projectId;
+    return {
+      projectId: profile.active_project_id,
+      projectName: profile.active_project_name ?? 'unnamed',
+    };
   },
 };
-
-export type { GlobioConfig };

package/src/lib/manage.ts

@@ -0,0 +1,84 @@
+import { config } from './config.js';
+
+const API_BASE_URL = 'https://api.globio.stanlink.online';
+const CONSOLE_BASE_URL = 'https://console.globio.stanlink.online';
+
+interface ManageRequestOptions {
+  method?: string;
+  body?: unknown;
+  token?: string;
+  profileName?: string;
+}
+
+export interface ManageAccount {
+  id: string;
+  email: string;
+  display_name: string | null;
+  avatar_url: string | null;
+  created_at: number;
+}
+
+export interface ManageOrg {
+  id: string;
+  name: string;
+  slug: string;
+  role: 'owner' | 'admin' | 'developer' | 'viewer';
+  created_at: number;
+}
+
+export interface ManageProject {
+  id: string;
+  name: string;
+  slug: string;
+  org_id: string;
+  org_name: string;
+  environment: string;
+  active: boolean;
+}
+
+export interface ManageProjectKey {
+  id: string;
+  name: string;
+  key_prefix: string;
+  scope: string;
+  created_at: number;
+  last_used_at: number | null;
+  token?: string;
+}
+
+function getAuthToken(explicitToken?: string, profileName?: string): string | undefined {
+  if (explicitToken) return explicitToken;
+  return config.getProfile(profileName)?.pat;
+}
+
+export async function manageRequest<T>(
+  path: string,
+  options: ManageRequestOptions = {}
+): Promise<T> {
+  const headers = new Headers();
+  if (!(options.body instanceof FormData)) {
+    headers.set('Content-Type', 'application/json');
+  }
+
+  const token = getAuthToken(options.token, options.profileName);
+  if (token) {
+    headers.set('Authorization', `Bearer ${token}`);
+  }
+
+  const response = await fetch(`${API_BASE_URL}/manage${path}`, {
+    method: options.method ?? 'GET',
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined,
+  });
+
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(payload.error || payload.message || 'Management request failed');
+  }
+
+  return (payload.data ?? payload) as T;
+}
+
+export function getConsoleCliAuthUrl(state: string): string {
+  return `${CONSOLE_BASE_URL}/cli-auth?state=${encodeURIComponent(state)}`;
+}

package/src/lib/sdk.ts

@@ -1,9 +1,12 @@
 import { Globio } from '@globio/sdk';
 import { config } from './config.js';
 
-export function getClient(): Globio {
-  const apiKey = config.requireAuth();
-  config.requireProject();
+export function getClient(profileName?: string): Globio {
+  const { pat } = config.requireAuth(profileName);
+  const { projectId } = config.requireProject(profileName);
+  const profile = config.getProfile(profileName);
+  const apiKey = profile?.project_api_key ?? pat;
+  void projectId;
   return new Globio({ apiKey });
 }
 

package/src/prompts/init.ts

@@ -3,18 +3,6 @@ import * as p from '@clack/prompts';
 export async function promptInit() {
   return p.group(
     {
-      apiKey: () =>
-        p.text({
-          message: 'Globio API key',
-          placeholder: 'gk_live_...',
-          validate: (value) => (!value ? 'Required' : undefined),
-        }),
-      projectId: () =>
-        p.text({
-          message: 'Project ID',
-          placeholder: 'proj_...',
-          validate: (value) => (!value ? 'Required' : undefined),
-        }),
       migrateFromFirebase: () =>
         p.confirm({
           message: 'Migrating from Firebase?',