@juuno-sdk/cli 1.0.10 → 1.0.12

package/README.md

@@ -75,6 +75,39 @@ npx juuno-cli whoami
 npx juuno-cli logout
 ```
 
+### Profiles
+
+The CLI supports multiple named profiles (like AWS CLI), each with its own
+token and API URL stored in `~/.juuno/credentials.json`. Use profiles to switch
+between production, staging, or multiple accounts without re-logging in.
+
+```bash
+# Log in to the default (production) profile
+npx juuno-cli login
+
+# Log in to a "stage" profile pointing at staging
+npx juuno-cli login --profile stage --api-url https://api.stage.juuno.co
+
+# Use a profile for a single command
+npx juuno-cli list --profile stage
+npx juuno-cli deploy --profile stage
+
+# Or set it for the whole shell
+export JUUNO_PROFILE=stage
+npx juuno-cli list
+
+# Inspect all profiles
+npx juuno-cli whoami --all
+
+# Log out of a single profile, or all of them
+npx juuno-cli logout --profile stage
+npx juuno-cli logout --all
+```
+
+The API URL given at login time is stored with the profile, so `--profile
+stage` alone is enough on subsequent commands. Override it on any single
+command with `JUUNO_API_URL`.
+
 ### Deployment
 
 Deploy your app to Juuno.
@@ -232,28 +265,38 @@ Options:
 juuno-cli login [options]
 
 Options:
+  --profile <name>  Profile to save credentials under (default: "default")
+  --api-url <url>   API URL to authenticate against and store on the profile
+                    (default: profile's URL or https://api.juuno.co)
   --email <email>   Your Juuno email (will prompt if not provided)
   --password <pwd>  Your Juuno password (will prompt if not provided)
   --help            Show help
 ```
 
-Saves credentials to `~/.juuno/credentials.json` for automatic reuse.
+Saves credentials to `~/.juuno/credentials.json` for automatic reuse. Multiple
+profiles can coexist in the same file.
 
 ### Logout Command
 
 ```bash
-juuno-cli logout
-```
+juuno-cli logout [options]
 
-Removes stored credentials from `~/.juuno/credentials.json`.
+Options:
+  --profile <name>  Profile to log out of (default: "default")
+  --all             Remove every profile
+  --help            Show help
+```
 
 ### Whoami Command
 
 ```bash
-juuno-cli whoami
-```
+juuno-cli whoami [options]
 
-Shows current authentication status.
+Options:
+  --profile <name>  Profile to inspect (default: "default")
+  --all             List every configured profile
+  --help            Show help
+```
 
 ### Deploy Command
 
@@ -262,6 +305,7 @@ juuno-cli deploy [options]
 
 Options:
   --build-dir <dir> Build directory to deploy (default: ./dist)
+  --profile <name>  Use credentials from the given profile
   --token <token>   Override with specific token (for CI/CD)
   --email <email>   Login with email instead of using saved credentials
   --password <pwd>  Use with --email
@@ -274,6 +318,7 @@ Options:
 juuno-cli list [options]
 
 Options:
+  --profile <name>  Use credentials from the given profile
   --token <token>   Override with specific token (for CI/CD)
   --email <email>   Login with email instead of using saved credentials
   --password <pwd>  Use with --email
@@ -289,6 +334,7 @@ Arguments:
   <app-id>          The app ID to get information about
 
 Options:
+  --profile <name>  Use credentials from the given profile
   --token <token>   Override with specific token (for CI/CD)
   --email <email>   Login with email instead of using saved credentials
   --password <pwd>  Use with --email
@@ -298,16 +344,19 @@ Options:
 ## Environment Variables
 
 ```bash
-# API endpoint (defaults to production)
-export JUUNO_API_URL=https://api.juuno.co
+# Profile to use (default: "default")
+export JUUNO_PROFILE=stage
 
-# For staging
+# API endpoint override (default: profile's URL or https://api.juuno.co)
 export JUUNO_API_URL=https://api.stage.juuno.co
 
 # Authentication token (for CI/CD, overrides saved credentials)
 export JUUNO_API_TOKEN=your-auth-token
 ```
 
+Precedence for API URL: `JUUNO_API_URL` > profile's stored `api_url` > default.
+Precedence for profile: `--profile` flag > `JUUNO_PROFILE` > `"default"`.
+
 ## Deployment Workflow
 
 ### Quick Start
@@ -381,7 +430,8 @@ The CLI checks for credentials in this order:
 
 1. `--token` flag (explicit override)
 2. `JUUNO_API_TOKEN` environment variable (CI/CD)
-3. Saved credentials from `~/.juuno/credentials.json` (from `juuno-cli login`)
+3. Saved credentials for the active profile in `~/.juuno/credentials.json`
+   (profile resolution: `--profile` > `JUUNO_PROFILE` > `"default"`)
 4. `--email` and `--password` flags (one-off login)
 5. Error: "Not logged in"
 

package/bin/cli-router.js

@@ -10,11 +10,15 @@ export function parseAuthOptions(args) {
   const emailIndex = args.indexOf('--email');
   const passwordIndex = args.indexOf('--password');
   const tokenIndex = args.indexOf('--token');
+  const profileIndex = args.indexOf('--profile');
+  const apiUrlIndex = args.indexOf('--api-url');
 
   return {
     email: emailIndex !== -1 ? args[emailIndex + 1] : undefined,
     password: passwordIndex !== -1 ? args[passwordIndex + 1] : undefined,
     token: tokenIndex !== -1 ? args[tokenIndex + 1] : undefined,
+    profile: profileIndex !== -1 ? args[profileIndex + 1] : undefined,
+    apiUrl: apiUrlIndex !== -1 ? args[apiUrlIndex + 1] : undefined,
   };
 }
 
@@ -32,21 +36,30 @@ export async function runCommand(command, args, importPrefix) {
     if (command === 'login') {
       const { login } = await import(`${importPrefix}login/index.js`);
       const authOptions = parseAuthOptions(args);
-      await login({ email: authOptions.email, password: authOptions.password });
+      await login({
+        email: authOptions.email,
+        password: authOptions.password,
+        profile: authOptions.profile,
+        apiUrl: authOptions.apiUrl,
+      });
       return 0;
     }
 
     // Handle logout command.
     if (command === 'logout') {
       const { logout } = await import(`${importPrefix}logout/index.js`);
-      await logout();
+      const authOptions = parseAuthOptions(args);
+      const all = args.includes('--all');
+      await logout({ profile: authOptions.profile, all });
       return 0;
     }
 
     // Handle whoami command.
     if (command === 'whoami') {
       const { whoami } = await import(`${importPrefix}whoami/index.js`);
-      await whoami();
+      const authOptions = parseAuthOptions(args);
+      const all = args.includes('--all');
+      await whoami({ profile: authOptions.profile, all });
       return 0;
     }
 
@@ -56,8 +69,9 @@ export async function runCommand(command, args, importPrefix) {
       const buildDirIndex = args.indexOf('--build-dir');
       const buildDir =
         buildDirIndex !== -1 ? args[buildDirIndex + 1] : './dist';
+      const skipIfDeployed = args.includes('--skip-if-deployed');
       const authOptions = parseAuthOptions(args);
-      await deployApp({ buildDir, ...authOptions });
+      await deployApp({ buildDir, skipIfDeployed, ...authOptions });
       return 0;
     }
 

package/bin/cli.js

@@ -36,16 +36,25 @@ Commands:
   info <app-id>     Show detailed information about an app
   help              Show this help message
 
+Profiles:
+  The CLI supports multiple named profiles (like AWS CLI), each storing its own
+  token and API URL in ~/.juuno/credentials.json. Use profiles to switch between
+  environments (e.g. production, staging) without re-logging in.
+
+  --profile <name>          Target a specific profile (default: "default")
+  JUUNO_PROFILE=<name>      Same, via environment variable
+
 Authentication Commands:
-  login [--email <email>] [--password <pwd>]
-    Authenticate and save credentials to ~/.juuno/credentials.json
-    Subsequent commands will use the saved token automatically.
+  login [--profile <name>] [--api-url <url>] [--email <email>] [--password <pwd>]
+    Authenticate and save credentials to the given profile. The API URL used
+    at login time is stored with the profile, so --profile <name> alone is
+    enough on subsequent commands.
 
-  logout
-    Remove stored credentials.
+  logout [--profile <name>] [--all]
+    Remove stored credentials for a profile. --all removes every profile.
 
-  whoami
-    Show current authentication status.
+  whoami [--profile <name>] [--all]
+    Show current authentication status. --all lists every configured profile.
 
 Dev Command (Unified Workflow):
   juuno-cli dev
@@ -61,23 +70,45 @@ Simulator Options:
   --serve-port <number> Port for Vite dev server in auto mode (default: 3000)
 
 Deploy Options:
-  --build-dir <dir>    Build directory to deploy (default: ./dist)
+  --build-dir <dir>        Build directory to deploy (default: ./dist)
+  --skip-if-deployed       Exit 0 with a notice if the manifest version is
+                           already live, instead of erroring. Intended for CI.
 
 Authentication Options (for deploy, list, info):
   By default, these commands use the token saved by 'juuno-cli login'.
   You can override with:
+  --profile <name>     Use credentials from a named profile
   --token <token>      Use specific token (for CI/CD)
   --email <email>      Login with email/password (skips saved token)
   --password <pwd>     Use with --email
 
 Environment Variables:
-  JUUNO_API_URL     API URL (default: https://api.juuno.co)
+  JUUNO_PROFILE     Profile to use (default: "default")
+  JUUNO_API_URL     API URL override (default: profile's URL or https://api.juuno.co)
   JUUNO_API_TOKEN   Authentication token (for CI/CD, skips saved credentials)
 
 Examples:
   # Authenticate (one-time setup)
   juuno-cli login
 
+  # Log in to a staging profile
+  juuno-cli login --profile stage --api-url https://api.stage.juuno.co
+
+  # Use a specific profile for any command
+  juuno-cli list --profile stage
+  juuno-cli deploy --profile stage
+
+  # Or set it for the whole shell
+  export JUUNO_PROFILE=stage
+  juuno-cli list
+
+  # Inspect all profiles
+  juuno-cli whoami --all
+
+  # Log out of a single profile, or all of them
+  juuno-cli logout --profile stage
+  juuno-cli logout --all
+
   # Start unified dev environment (recommended)
   cd my-juuno-app
   juuno-cli dev
@@ -94,12 +125,6 @@ Examples:
 
   # Show app info (uses saved credentials)
   juuno-cli info app_abc123
-
-  # Check authentication status
-  juuno-cli whoami
-
-  # Logout
-  juuno-cli logout
   `);
   process.exit(0);
 }

package/dist/cli/src/auth/index.js

@@ -2,16 +2,16 @@ import inquirer from 'inquirer';
 import { homedir } from 'os';
 import { join } from 'path';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, } from 'fs';
+export const DEFAULT_PROFILE = 'default';
+const DEFAULT_API_URL = 'https://api.juuno.co';
 /**
- * Gets the credentials file path.
+ * In-memory cache of the parsed credentials file, invalidated on write.
+ * Prevents repeated disk reads across multiple auth helpers in a single command.
  */
+let cachedFile = null;
 function getCredentialsPath() {
-    const configDir = join(homedir(), '.juuno');
-    return join(configDir, 'credentials.json');
+    return join(homedir(), '.juuno', 'credentials.json');
 }
-/**
- * Ensures the credentials directory exists.
- */
 function ensureCredentialsDir() {
     const configDir = join(homedir(), '.juuno');
     if (!existsSync(configDir)) {
@@ -19,60 +19,147 @@ function ensureCredentialsDir() {
     }
 }
 /**
- * Saves authentication token to local credentials file.
+ * Reads and parses the credentials file. Migrates legacy single-profile
+ * files to the new profiles format transparently.
  */
-export function saveToken(token) {
+function readCredentialsFile() {
+    if (cachedFile) {
+        return cachedFile;
+    }
+    const credentialsPath = getCredentialsPath();
+    if (!existsSync(credentialsPath)) {
+        cachedFile = { profiles: {} };
+        return cachedFile;
+    }
+    const fileContent = readFileSync(credentialsPath, 'utf-8');
+    const parsed = JSON.parse(fileContent);
+    if (parsed && typeof parsed === 'object' && 'profiles' in parsed) {
+        cachedFile = parsed;
+        return cachedFile;
+    }
+    // Legacy format: { token, api_url, created_at }. Migrate to default profile.
+    if (parsed && typeof parsed === 'object' && 'token' in parsed) {
+        const legacy = parsed;
+        cachedFile = {
+            profiles: {
+                [DEFAULT_PROFILE]: {
+                    token: legacy.token,
+                    api_url: legacy.api_url || DEFAULT_API_URL,
+                    created_at: legacy.created_at || new Date().toISOString(),
+                },
+            },
+        };
+        return cachedFile;
+    }
+    cachedFile = { profiles: {} };
+    return cachedFile;
+}
+function writeCredentialsFile(file) {
     ensureCredentialsDir();
-    const credentials = {
-        token,
-        api_url: getApiUrl(),
-        created_at: new Date().toISOString(),
-    };
     const credentialsPath = getCredentialsPath();
-    writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+    writeFileSync(credentialsPath, JSON.stringify(file, null, 2), {
         mode: 0o600,
     });
+    cachedFile = file;
 }
 /**
- * Loads authentication token from local credentials file.
+ * Resolves the profile name from options, environment, or default.
  */
-export function loadToken() {
-    const credentialsPath = getCredentialsPath();
-    if (!existsSync(credentialsPath)) {
-        return null;
+export function resolveProfile(options = {}) {
+    if (options.profile) {
+        return options.profile;
     }
-    try {
-        const fileContent = readFileSync(credentialsPath, 'utf-8');
-        const credentials = JSON.parse(fileContent);
-        return credentials.token || null;
+    return process.env.JUUNO_PROFILE || DEFAULT_PROFILE;
+}
+/**
+ * Formats a "--profile <name>" CLI flag suffix for help/error text, or an
+ * empty string when the profile is the default.
+ */
+export function formatProfileFlag(profile) {
+    return profile === DEFAULT_PROFILE ? '' : ` --profile ${profile}`;
+}
+/**
+ * Lists all saved profile names.
+ */
+export function listProfiles() {
+    return Object.keys(readCredentialsFile().profiles).sort();
+}
+/**
+ * Returns the stored credentials for a profile, or null if missing.
+ */
+export function getProfile(profile) {
+    return readCredentialsFile().profiles[profile] || null;
+}
+/**
+ * Saves authentication token to the given profile.
+ */
+export function saveToken(token, profile, apiUrl) {
+    const file = readCredentialsFile();
+    file.profiles[profile] = {
+        token,
+        api_url: apiUrl,
+        created_at: new Date().toISOString(),
+    };
+    writeCredentialsFile(file);
+}
+/**
+ * Loads authentication token for the given profile.
+ */
+export function loadToken(profile) {
+    return getProfile(profile)?.token || null;
+}
+/**
+ * Removes a single profile from the credentials file.
+ * Deletes the file if no profiles remain.
+ */
+export function removeProfile(profile) {
+    const file = readCredentialsFile();
+    if (!(profile in file.profiles)) {
+        return false;
     }
-    catch (error) {
-        return null;
+    delete file.profiles[profile];
+    if (Object.keys(file.profiles).length === 0) {
+        const credentialsPath = getCredentialsPath();
+        if (existsSync(credentialsPath)) {
+            unlinkSync(credentialsPath);
+        }
+        cachedFile = { profiles: {} };
+        return true;
     }
+    writeCredentialsFile(file);
+    return true;
 }
 /**
- * Removes stored credentials file.
+ * Removes all profiles by deleting the credentials file.
  */
-export function removeToken() {
+export function removeAllProfiles() {
     const credentialsPath = getCredentialsPath();
     if (existsSync(credentialsPath)) {
         unlinkSync(credentialsPath);
     }
+    cachedFile = { profiles: {} };
 }
 /**
- * Checks if user is currently logged in.
+ * Checks whether a profile has stored credentials.
  */
-export function isLoggedIn() {
-    return loadToken() !== null;
+export function isLoggedIn(profile) {
+    return loadToken(profile) !== null;
 }
 /**
- * Gets the API URL from environment or uses default.
+ * Resolves the API URL with precedence: options override, env var, profile, default.
  */
-export function getApiUrl() {
-    return process.env.JUUNO_API_URL || 'https://api.juuno.co';
+export function getApiUrl(options = {}) {
+    if (options.apiUrl) {
+        return options.apiUrl;
+    }
+    if (process.env.JUUNO_API_URL) {
+        return process.env.JUUNO_API_URL;
+    }
+    const profile = getProfile(resolveProfile(options));
+    return profile?.api_url || DEFAULT_API_URL;
 }
 /**
- * Gets the authentication token from options, environment, or stored credentials.
+ * Gets the authentication token from options, environment, or stored profile.
  */
 export async function getAuthToken(options) {
     if (options.token) {
@@ -82,15 +169,18 @@ export async function getAuthToken(options) {
     if (envToken) {
         return envToken;
     }
-    const storedToken = loadToken();
+    const profile = resolveProfile(options);
+    const storedToken = loadToken(profile);
     if (storedToken) {
         return storedToken;
     }
     if (options.email || options.password) {
         const credentials = await getCredentials(options);
-        return await loginWithCredentials(credentials);
+        return await loginWithCredentials(credentials, getApiUrl(options));
     }
-    throw new Error('Not logged in. Please run "juuno-cli login" first or provide credentials via --email and --password');
+    const profileFlag = formatProfileFlag(profile);
+    const suffix = profile === DEFAULT_PROFILE ? '' : ` for profile "${profile}"`;
+    throw new Error(`Not logged in${suffix}. Please run "juuno-cli login${profileFlag}" first or provide credentials via --email and --password`);
 }
 /**
  * Gets credentials from options or prompts the user.
@@ -123,8 +213,7 @@ async function getCredentials(options) {
 /**
  * Authenticates with the developer API using email and password.
  */
-export async function loginWithCredentials(credentials) {
-    const apiUrl = getApiUrl();
+export async function loginWithCredentials(credentials, apiUrl) {
     const loginUrl = `${apiUrl}/api/v1/developer/auth/login`;
     try {
         const response = await fetch(loginUrl, {

package/dist/cli/src/deploy/index.js

@@ -6,8 +6,7 @@ import { getAuthToken, getApiUrl } from '../auth/index.js';
  * Fetches the currently deployed version of an app.
  * Returns null if the app doesn't exist yet.
  */
-async function fetchDeployedVersion(token, appId) {
-    const apiUrl = getApiUrl();
+async function fetchDeployedVersion(token, appId, apiUrl) {
     const infoUrl = `${apiUrl}/api/v1/developer/apps/${appId}`;
     try {
         const response = await fetch(infoUrl, {
@@ -78,8 +77,7 @@ async function createZipBundle(buildDir) {
 /**
  * Uploads the app bundle to the developer API.
  */
-async function uploadBundle(token, zipBuffer) {
-    const apiUrl = getApiUrl();
+async function uploadBundle(token, zipBuffer, apiUrl) {
     const uploadUrl = `${apiUrl}/api/v1/developer/apps/upload`;
     const formData = new FormData();
     const blob = new Blob([zipBuffer], { type: 'application/zip' });
@@ -137,6 +135,7 @@ export async function deployApp(options) {
     console.log(`   Version: ${manifest.version}`);
     console.log(`   ID: ${manifest.id}`);
     console.log('');
+    const apiUrl = getApiUrl(options);
     console.log('🔑 Authenticating...');
     let token;
     try {
@@ -150,8 +149,14 @@ export async function deployApp(options) {
     }
     // Check if this version is already deployed.
     console.log('🔍 Checking deployed version...');
-    const deployedVersion = await fetchDeployedVersion(token, manifest.id);
+    const deployedVersion = await fetchDeployedVersion(token, manifest.id, apiUrl);
     if (deployedVersion !== null && deployedVersion === manifest.version) {
+        if (options.skipIfDeployed) {
+            console.log('');
+            console.log(`ℹ️  ${manifest.name}@${manifest.version} already deployed, skipping.`);
+            console.log('');
+            return;
+        }
         console.error('');
         console.error(`❌ Version ${manifest.version} is already deployed for '${manifest.name}'`);
         console.error('');
@@ -180,7 +185,7 @@ export async function deployApp(options) {
     console.log('☁️  Uploading to Juuno...');
     let result;
     try {
-        result = await uploadBundle(token, zipBuffer);
+        result = await uploadBundle(token, zipBuffer, apiUrl);
         console.log('   ✓ Upload complete');
         console.log('');
     }

package/dist/cli/src/info/index.js

@@ -2,8 +2,7 @@ import { getAuthToken, getApiUrl } from '../auth/index.js';
 /**
  * Fetches detailed information about a specific app.
  */
-async function fetchAppInfo(token, appId) {
-    const apiUrl = getApiUrl();
+async function fetchAppInfo(token, appId, apiUrl) {
     const infoUrl = `${apiUrl}/api/v1/developer/apps/${appId}`;
     try {
         const response = await fetch(infoUrl, {
@@ -85,6 +84,7 @@ export async function getAppInfo(options) {
         console.error('   Usage: juuno-cli info <app-id>');
         process.exit(1);
     }
+    const apiUrl = getApiUrl(options);
     console.log('🔑 Authenticating...');
     let token;
     try {
@@ -99,7 +99,7 @@ export async function getAppInfo(options) {
     console.log(`📡 Fetching app info for: ${options.appId}`);
     let appInfo;
     try {
-        appInfo = await fetchAppInfo(token, options.appId);
+        appInfo = await fetchAppInfo(token, options.appId, apiUrl);
         console.log('   ✓ Info retrieved');
         console.log('');
     }

package/dist/cli/src/list/index.js

@@ -2,8 +2,7 @@ import { getAuthToken, getApiUrl } from '../auth/index.js';
 /**
  * Fetches the list of developer apps from the API.
  */
-async function fetchAppList(token) {
-    const apiUrl = getApiUrl();
+async function fetchAppList(token, apiUrl) {
     const listUrl = `${apiUrl}/api/v1/developer/apps`;
     try {
         const response = await fetch(listUrl, {
@@ -76,6 +75,7 @@ function displayAppList(apps) {
 export async function listApps(options) {
     console.log('📦 Juuno CLI - List Apps');
     console.log('');
+    const apiUrl = getApiUrl(options);
     console.log('🔑 Authenticating...');
     let token;
     try {
@@ -90,7 +90,7 @@ export async function listApps(options) {
     console.log('📡 Fetching apps...');
     let apps;
     try {
-        apps = await fetchAppList(token);
+        apps = await fetchAppList(token, apiUrl);
         console.log('   ✓ Apps retrieved');
         console.log('');
     }

package/dist/cli/src/login/index.js

@@ -1,13 +1,15 @@
-import { loginWithCredentials, saveToken, getApiUrl, } from '../auth/index.js';
+import { loginWithCredentials, saveToken, getApiUrl, resolveProfile, formatProfileFlag, } from '../auth/index.js';
 import inquirer from 'inquirer';
 /**
- * Logs in to Juuno and saves authentication token.
+ * Logs in to Juuno and saves authentication token for the target profile.
  */
 export async function login(options) {
+    const profile = resolveProfile(options);
+    const apiUrl = getApiUrl(options);
     console.log('📦 Juuno CLI - Login');
     console.log('');
-    const apiUrl = getApiUrl();
-    console.log(`   API: ${apiUrl}`);
+    console.log(`   Profile: ${profile}`);
+    console.log(`   API:     ${apiUrl}`);
     console.log('');
     let email = options.email;
     let pwd = options.password;
@@ -39,15 +41,15 @@ export async function login(options) {
     console.log('🔑 Authenticating...');
     let token;
     try {
-        token = await loginWithCredentials(credentials);
+        token = await loginWithCredentials(credentials, apiUrl);
     }
     catch (error) {
         console.error(`❌ ${error instanceof Error ? error.message : String(error)}`);
         process.exit(1);
     }
     try {
-        saveToken(token);
-        console.log('   ✓ Token saved to ~/.juuno/credentials.json');
+        saveToken(token, profile, apiUrl);
+        console.log(`   ✓ Token saved to ~/.juuno/credentials.json (profile: ${profile})`);
         console.log('');
     }
     catch (error) {
@@ -56,6 +58,7 @@ export async function login(options) {
     }
     console.log('✅ Login successful!');
     console.log('');
-    console.log('💡 You can now use deploy, list, and info commands without re-authenticating.');
+    const profileFlag = formatProfileFlag(profile);
+    console.log(`💡 You can now use deploy, list, and info commands${profileFlag ? ` with${profileFlag}` : ''} without re-authenticating.`);
     console.log('');
 }