@revoengine/cli 1.0.0 → 1.0.2

package/README.md

@@ -27,7 +27,9 @@ Log in and save your default credentials:
 revo auth login
 ```
 
-`revo auth login` opens an interactive terminal prompt for your API key and instance ID. If you are already logged in, the CLI warns and asks you to `revo auth logout` first.
+`revo auth login` opens an interactive terminal prompt for your API key. If you are already logged in, the CLI warns and asks you to `revo auth logout` first.
+
+The CLI validates the API key against `/api/v1/me` and infers the RevoEngine instance from the authenticated profile for tenant-scoped operations such as component push.
 
 Check the active session:
 
@@ -52,10 +54,9 @@ Initialize a project for ambient low-code editor globals:
 ```bash
 revo project
 revo project init ./app
-revo project switch a931e927-738d-42a4-b486-5fc19bfb3dfb
 ```
 
-This writes `.revoengine/types/revo.editor.d.ts`, `.revoengine/revo.json`, patches `tsconfig.json` or `jsconfig.json`, and updates `.gitignore` so the generated type bundle stays local by default. `revo project switch <instanceId>` rebinds the current project to another stored instance and refreshes the ambient editor types for that instance.
+This writes `.revoengine/types/revo.editor.d.ts`, `.revoengine/revo.json`, patches `tsconfig.json` or `jsconfig.json`, and updates `.gitignore` so the generated type bundle stays local by default.
 
 ## Common commands
 
@@ -135,12 +136,14 @@ Components with `category: null` are stored under `Components/__no_category__/..
 Bulk sync behavior:
 
 - `revo component pull --all` and `revo component push --all` require terminal confirmation unless `--force` is passed.
+- `revo component pull --all` requests only active remote components where `deletedAt` is empty.
 - Pull compares the full local workspace contract before overwriting anything.
 - Pull skips with `no changes` when the local workspace already matches the remote component.
 - Pull skips with `changed` when local files differ from the remote contract.
 - Pull skips with `stale version` when the local version is older than the remote version, unless `--stale` or `--force` is passed.
 - Push treats backend `Not modified` responses as skipped instead of failing the whole run.
-- Debug posts the local `component.json` plus `elements/{order}_{key}.{js|ts}` source files to the instance sandbox `debug` endpoint.
+- Push treats backend `404` responses as skipped with `doesn't exist remotely`; restore the component in RevoEngine before pushing local changes to it.
+- Debug posts the local `component.json` plus `elements/{order}_{key}.{js|ts}` source files to the authenticated sandbox `debug` endpoint.
 - Sync logs show direction explicitly: `RevoEngine -> path` for pull and `RevoEngine <- path` for push.
 - Bulk runs print a summary such as `Deployed 54/67, Skipped 13/67 in 13s`.
 
@@ -148,8 +151,8 @@ Bulk sync behavior:
 
 The CLI reads configuration in this order:
 
-1. CLI flags such as `--url`, `--instance`, and `--token`
-2. Environment variables such as `REVO_URL`, `REVO_INSTANCE`, and `REVO_TOKEN`
+1. CLI flags such as `--url` and `--token`
+2. Environment variables such as `REVO_URL` and `REVO_TOKEN`
 3. Stored config in the OS config directory
 
 This means environment variables override the locally stored config, which is the intended setup for CI and non-interactive automation.
@@ -158,7 +161,7 @@ Use `--url` for one-off local or dedicated API targets:
 
 ```bash
 revo --url https://api.test.revong.com -i
-revo --url https://api.test.revong.com auth login --instance a931e927-738d-42a4-b486-5fc19bfb3dfb
+revo --url https://api.test.revong.com auth login
 revo --url https://api.revoengine.com endpoints
 ```
 
@@ -167,13 +170,11 @@ Use environment variables for CI/CD or shell profiles:
 ```bash
 # TEST
 export REVO_URL="https://api.test.revong.com"
-export REVO_INSTANCE="a931e927-738d-42a4-b486-5fc19bfb3dfb"
 export REVO_TOKEN="your-test-token"
 revo endpoints
 
 # PROD
 export REVO_URL="https://api.revoengine.com"
-export REVO_INSTANCE="a931e927-738d-42a4-b486-5fc19bfb3dfb"
 export REVO_TOKEN="your-prod-token"
 revo endpoints
 ```
@@ -181,17 +182,15 @@ revo endpoints
 Supported environment variables:
 
 - `REVO_URL` or `REVO_BASE_URL`
-- `REVO_INSTANCE`
 - `REVO_TOKEN` or `REVO_API_KEY`
+- `REVO_NO_UPDATE_NOTIFIER`
 - `REVOENGINE_URL` or `REVOENGINE_BASE_URL`
-- `REVOENGINE_INSTANCE`
 - `REVOENGINE_TOKEN` or `REVOENGINE_API_KEY`
 
 Example for CI:
 
 ```bash
 export REVO_URL="https://api.revoengine.com"
-export REVO_INSTANCE="a931e927-738d-42a4-b486-5fc19bfb3dfb"
 export REVO_TOKEN="your-ci-token"
 revo endpoints
 ```
@@ -201,6 +200,22 @@ Stored config lives in:
 - macOS and Linux: `~/.config/revoengine`
 - Windows: `%APPDATA%/revoengine`
 
+## Update notifications
+
+When running in an interactive terminal, the CLI checks the npm registry at most once every 24 hours and prints a colored notice on stderr when a newer `@revoengine/cli` version is available.
+
+Disable the check for one run:
+
+```bash
+revo --no-update-notifier endpoints
+```
+
+Disable it through the environment:
+
+```bash
+export REVO_NO_UPDATE_NOTIFIER=1
+```
+
 ## Local development
 
 ```bash

package/dist/src/cli.js

@@ -5,6 +5,7 @@ import { resolveRuntimeConfig } from "./config.js";
 import { handleAuthCommand, handleComponentCommand, handleEndpointsCommand, handleInfoCommand, handleProjectCommand, handleRequestCommand, handleSearchCommand, } from "./commands/index.js";
 import { buildRuntimeViewModel } from "./runtime-view.js";
 import { renderHelp, renderOverview } from "./ui.js";
+import { maybeNotifyUpdateAvailable } from "./update-notifier.js";
 import { readPackageVersion } from "./utils.js";
 const packageVersion = readPackageVersion();
 const ANSI = {
@@ -159,6 +160,10 @@ function printHelp() {
 }
 export async function main(argv = process.argv.slice(2)) {
     const args = parseArgs(argv);
+    await maybeNotifyUpdateAvailable({
+        args,
+        currentVersion: packageVersion,
+    });
     const command = args._[0];
     const noPositionals = args._.length === 0;
     if (command === 'version' || ((args.version !== undefined || args.V !== undefined) && noPositionals)) {

package/dist/src/client.d.ts

@@ -35,6 +35,7 @@ export declare class PermissionDeniedError extends ApiError {
 }
 declare function buildUrl(baseUrl: string, requestPath: string, query?: Record<string, unknown>): URL;
 declare function normalizeToken(token?: string): string;
+export declare function extractProfileInstanceId(profile: unknown): string;
 export declare class RevoClient {
     baseUrl: string;
     instance: string;
@@ -66,7 +67,6 @@ export declare class RevoClient {
     search(params: Record<string, unknown>): Promise<unknown>;
     listComponents(options?: ComponentListRequest): Promise<unknown>;
     getComponent(componentId: string): Promise<unknown>;
-    createComponent(body: Record<string, unknown>): Promise<ApiResponse<unknown>>;
     saveComponentElements(componentId: string, body: unknown): Promise<ApiResponse<unknown>>;
 }
 export { buildUrl, normalizeToken };

package/dist/src/client.js

@@ -1,4 +1,4 @@
-import { AUTH_VALIDATION_TTL_MS, buildAuthValidationKey, DEFAULT_BASE_URL, isUuid, readAuthValidationState, resolveRuntimeConfig, saveAuthValidationState, } from "./config.js";
+import { AUTH_VALIDATION_TTL_MS, buildAuthValidationKey, DEFAULT_BASE_URL, readAuthValidationState, resolveRuntimeConfig, saveAuthValidationState, } from "./config.js";
 import { createSpinner } from "./spinner.js";
 export class ApiError extends Error {
     status;
@@ -125,6 +125,30 @@ async function readResponseData(response) {
     }
     return text;
 }
+function readProfileInstanceId(profile) {
+    if (!profile || typeof profile !== 'object' || Array.isArray(profile)) {
+        return '';
+    }
+    const record = profile;
+    if (typeof record.id === 'string') {
+        return record.id;
+    }
+    const instance = record.instance;
+    if (instance && typeof instance === 'object' && !Array.isArray(instance)) {
+        const instanceId = instance.id;
+        if (typeof instanceId === 'string') {
+            return instanceId;
+        }
+    }
+    const data = record.data;
+    if (data && typeof data === 'object' && !Array.isArray(data)) {
+        return readProfileInstanceId(data);
+    }
+    return '';
+}
+export function extractProfileInstanceId(profile) {
+    return readProfileInstanceId(profile);
+}
 export class RevoClient {
     baseUrl;
     instance;
@@ -133,7 +157,7 @@ export class RevoClient {
     constructor(options = {}) {
         const config = resolveRuntimeConfig(options);
         this.baseUrl = config.baseUrl;
-        this.instance = config.instance;
+        this.instance = config.instance || '';
         this.token = config.token;
         this.fetchImpl = options.fetch || globalThis.fetch;
     }
@@ -154,12 +178,6 @@ export class RevoClient {
         if (!this.token) {
             throw new Error('Missing API token. Run `revo auth login` or set REVO_TOKEN / REVO_API_KEY.');
         }
-        if (!this.instance) {
-            throw new Error('Missing instance UUID. Run `revo auth login` or set REVO_INSTANCE.');
-        }
-        if (!isUuid(this.instance)) {
-            throw new Error(`Invalid instance UUID: ${this.instance}`);
-        }
     }
     async validateSession(options = {}) {
         this.assertReady();
@@ -173,6 +191,7 @@ export class RevoClient {
                 throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', null);
             }
             if (cached.profile !== undefined) {
+                this.instance = this.instance || extractProfileInstanceId(cached.profile);
                 return {
                     authenticated: true,
                     fromCache: true,
@@ -182,6 +201,7 @@ export class RevoClient {
         }
         try {
             const profile = await this.requestData('GET', '/api/v1/me', { authGuard: false });
+            this.instance = this.instance || extractProfileInstanceId(profile);
             saveAuthValidationState({
                 key: this.authValidationKey,
                 status: 'authenticated',
@@ -215,8 +235,10 @@ export class RevoClient {
         const headers = new Headers(options.headers || {});
         headers.set('Authorization', this.authHeader);
         headers.set('x-api-key', this.token);
-        headers.set('instance', this.instance);
-        headers.set('x-api-instance', this.instance);
+        if (this.instance) {
+            headers.set('instance', this.instance);
+            headers.set('x-api-instance', this.instance);
+        }
         let body = options.body;
         if (body !== undefined && body !== null && method.toUpperCase() !== 'GET') {
             headers.set('Content-Type', 'application/json');
@@ -305,9 +327,6 @@ export class RevoClient {
     async getComponent(componentId) {
         return this.requestData('GET', `/api/v1/component/${componentId}`);
     }
-    async createComponent(body) {
-        return this.request('POST', '/api/v1/component', { body });
-    }
     async saveComponentElements(componentId, body) {
         return this.request('POST', `/api/v1/component/${componentId}/save`, { body });
     }

package/dist/src/commands/auth.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { clearAuthValidationState, clearStoredConfig, getConfigDir, isUuid, loadStoredConfig, resolveRuntimeConfig, saveStoredConfig, } from "../config.js";
+import { clearAuthValidationState, clearStoredConfig, getConfigDir, loadStoredConfig, resolveRuntimeConfig, saveStoredConfig, } from "../config.js";
 import { readLegacyImportFromFile } from "../legacy.js";
 import { promptText } from "../prompt.js";
 import { buildRuntimeViewModel } from "../runtime-view.js";
@@ -8,28 +8,19 @@ import { readBoolFlag, readFlag } from "../utils.js";
 function getConfigInput(args) {
     return resolveRuntimeConfig({
         baseUrl: readFlag(args, ['url', 'baseUrl']) || '',
-        instance: readFlag(args, ['instance', 'i']) || '',
         token: readFlag(args, ['token', 't']) || '',
     });
 }
 async function promptMissingConfig(runtime) {
     let token = runtime.token;
-    let instance = runtime.instance;
     if (!token) {
         token = (await promptText('Paste API key (input is visible)')).trim();
     }
-    if (!instance) {
-        instance = (await promptText('Paste instance ID')).trim();
-    }
     if (!token) {
         throw new Error('API key is required.');
     }
-    if (!instance || !isUuid(instance)) {
-        throw new Error('Instance ID must be a UUID.');
-    }
     return {
         token,
-        instance,
         baseUrl: runtime.baseUrl,
     };
 }
@@ -44,7 +35,6 @@ export async function handleAuthCommand(context) {
     if (subcommand === 'get') {
         const stored = loadStoredConfig();
         print({
-            instance: stored.instance || null,
             baseUrl: stored.baseUrl,
             tokenConfigured: Boolean(stored.token),
             configDir: getConfigDir(),
@@ -52,21 +42,7 @@ export async function handleAuthCommand(context) {
         return;
     }
     if (subcommand === 'set') {
-        const instance = readFlag(args, ['instance', 'i']);
-        if (!instance) {
-            throw new Error('Missing instance UUID.');
-        }
-        if (!isUuid(instance)) {
-            throw new Error('Instance must be a UUID.');
-        }
-        const stored = loadStoredConfig();
-        saveStoredConfig({
-            baseUrl: stored.baseUrl,
-            token: stored.token,
-            instance,
-        });
-        println(`Saved default instance ${instance}.`);
-        return;
+        throw new Error('`revo auth set` was removed because API-key credentials are no longer instance-scoped.');
     }
     if (subcommand === 'status') {
         const view = await buildRuntimeViewModel(context, { forceValidation: true });
@@ -88,7 +64,7 @@ export async function handleAuthCommand(context) {
             client.token = imported.token;
             client.instance = imported.instance;
             client.baseUrl = imported.baseUrl;
-            if (imported.token && imported.instance) {
+            if (imported.token) {
                 try {
                     await client.validateSession({ force: true });
                 }
@@ -105,14 +81,13 @@ export async function handleAuthCommand(context) {
         throw new Error('Unknown auth command.');
     }
     const stored = loadStoredConfig();
-    if (stored.token && stored.instance) {
-        println(`Warning: already logged in for instance ${stored.instance}. Run \`revo auth logout\` before logging in again.`);
+    if (stored.token) {
+        println('Warning: already logged in. Run `revo auth logout` before logging in again.');
         return;
     }
     const runtime = getConfigInput(args);
-    const next = runtime.token && runtime.instance ? runtime : await promptMissingConfig(runtime);
+    const next = runtime.token ? runtime : await promptMissingConfig(runtime);
     client.token = next.token;
-    client.instance = next.instance;
     client.baseUrl = next.baseUrl;
     try {
         await client.validateSession({ force: true });
@@ -125,7 +100,10 @@ export async function handleAuthCommand(context) {
         error(`Saved credentials, but validation failed: ${String(validationError)}`);
         return;
     }
-    saveStoredConfig(next);
+    saveStoredConfig({
+        ...next,
+        instance: client.instance || undefined,
+    });
     clearAuthValidationState();
     println(`Logged in and saved credentials to ${getConfigDir()}.`);
 }

package/dist/src/commands/component.js

@@ -5,7 +5,11 @@ import { buildSandboxDebugUrl, extractSandboxEndpoint } from "../project.js";
 import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
 import { deepClone, readBoolFlag, readFlag, readValues, sanitizeSegment, writeJsonFile } from "../utils.js";
 const NULL_CATEGORY_FOLDER = '__no_category__';
-const COMPONENT_LIST_PAGE_SIZE = 100;
+const COMPONENT_LIST_PAGE_SIZE = 200;
+const ACTIVE_COMPONENT_LIST_FILTER = {
+    'filter[and][0][field]': 'deletedAt',
+    'filter[and][0][op]': 'isNull',
+};
 const ANSI = {
     reset: '\u001b[0m',
     bold: '\u001b[1m',
@@ -202,23 +206,6 @@ function getComponentFolder(component) {
     const componentId = sanitizeSegment(component.componentId || component.id || 'unknown');
     return path.join(categoryFolder, `${name}-${componentId}`);
 }
-function getCategoryFromManifestPath(manifestPath) {
-    const componentDir = path.dirname(manifestPath);
-    const categoryDir = path.basename(path.dirname(componentDir));
-    if (categoryDir === NULL_CATEGORY_FOLDER) {
-        return null;
-    }
-    return categoryDir;
-}
-function normalizeCategoryForApi(manifestPath, category) {
-    if (category === NULL_CATEGORY_FOLDER) {
-        return null;
-    }
-    if (category != null) {
-        return category;
-    }
-    return getCategoryFromManifestPath(manifestPath);
-}
 function getDetailsExtension(component) {
     return componentTypeToExtension(normalizeComponentType(component));
 }
@@ -351,6 +338,27 @@ function resolveNextComponentListRequest(value) {
     }
     return Object.keys(query).length > 0 ? { query } : null;
 }
+function buildActiveComponentListQuery(skip, take = COMPONENT_LIST_PAGE_SIZE) {
+    return {
+        take,
+        skip,
+        count: true,
+        ...ACTIVE_COMPONENT_LIST_FILTER,
+    };
+}
+function withActiveComponentListFilter(request) {
+    if (!request.query) {
+        return request;
+    }
+    return {
+        ...request,
+        query: {
+            ...request.query,
+            count: request.query.count ?? true,
+            ...ACTIVE_COMPONENT_LIST_FILTER,
+        },
+    };
+}
 function unwrapComponentListPage(value) {
     const items = unwrapList(value);
     if (!isRecord(value)) {
@@ -571,10 +579,7 @@ async function pullAllComponents(context, options) {
     const components = [];
     const seenRequests = new Set();
     let nextRequest = {
-        query: {
-            take: COMPONENT_LIST_PAGE_SIZE,
-            skip: 0,
-        },
+        query: buildActiveComponentListQuery(0),
     };
     let discoveredTotal = null;
     while (nextRequest) {
@@ -604,17 +609,14 @@ async function pullAllComponents(context, options) {
             continue;
         }
         if (page.nextRequest) {
-            nextRequest = page.nextRequest;
+            nextRequest = withActiveComponentListFilter(page.nextRequest);
             continue;
         }
         if (nextRequest.query
             && typeof nextRequest.query.take === 'number'
             && page.items.length === nextRequest.query.take) {
             nextRequest = {
-                query: {
-                    take: nextRequest.query.take,
-                    skip: components.length,
-                },
+                query: buildActiveComponentListQuery(components.length, nextRequest.query.take),
             };
             continue;
         }
@@ -655,15 +657,6 @@ async function pushSingleComponent(context, manifestPath) {
     if (!component.name) {
         throw new Error(`Missing component name in ${manifestPath}.`);
     }
-    const payload = {
-        componentId,
-        name: component.name,
-        category: normalizeCategoryForApi(manifestPath, component.category),
-        desc: component.desc,
-        type: normalizeComponentType(component),
-        active: component.active ?? true,
-        async: component.async ?? false,
-    };
     const elements = (component.elements || []).map((element) => ({
         key: element.key,
         desc: element.desc,
@@ -717,21 +710,16 @@ async function pushSingleComponent(context, manifestPath) {
             throw new Error('Access denied (403). You are authenticated, but you do not have permission to push components.');
         }
         if (error instanceof ApiError && error.status === 404) {
-            try {
-                await client.createComponent(payload);
-                await client.saveComponentElements(componentId, elements);
-            }
-            catch (createError) {
-                rethrowComponentAccessError(createError, 'push');
-            }
             const result = {
-                status: 'deployed',
+                status: 'skipped',
                 targetPath,
+                reason: "doesn't exist remotely",
             };
             printSyncStatus(println, {
-                status: 'Deployed',
+                status: 'Skipped',
                 direction: 'push',
                 targetPath,
+                reason: result.reason,
             });
             return result;
         }
@@ -837,7 +825,7 @@ async function debugSingleComponent(context, componentId) {
     const profile = await context.client.me();
     const sandboxEndpoint = extractSandboxEndpoint(profile);
     if (!sandboxEndpoint) {
-        throw new Error('Authenticated profile did not include `endpoints.sandbox`, so component debug cannot run for this instance.');
+        throw new Error('Authenticated profile did not include `endpoints.sandbox`, so component debug cannot run.');
     }
     const response = await context.client.debugComponent(buildSandboxDebugUrl(sandboxEndpoint), {
         elements: buildDebugElements(component),

package/dist/src/commands/project.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
-import { isUuid, loadStoredConfigIndex } from "../config.js";
-import { buildProjectSyncState, buildEditorTypesUrl, extractSandboxEndpoint, extractEditorTypesBundle, findProjectMetadataFile, resolveProjectInvocation, resolveProjectRoot, resolveProjectTarget, syncProjectFiles, } from "../project.js";
+import { buildProjectSyncState, buildEditorTypesUrl, extractSandboxEndpoint, extractEditorTypesBundle, resolveProjectInvocation, resolveProjectTarget, syncProjectFiles, } from "../project.js";
 function printSyncSummary(println, targetDir, result, prefix) {
     println(`${prefix} ${targetDir}`);
     println(`Wrote ${path.relative(targetDir, result.typesFile)}`);
@@ -20,12 +19,11 @@ async function resolveProjectSyncInput(context) {
     const profile = await client.me();
     const sandboxEndpoint = extractSandboxEndpoint(profile);
     if (!sandboxEndpoint) {
-        throw new Error('Authenticated profile did not include `endpoints.sandbox`, so editor types cannot be initialized for this instance.');
+        throw new Error('Authenticated profile did not include `endpoints.sandbox`, so editor types cannot be initialized.');
     }
     const bundle = extractEditorTypesBundle(await client.getEditorTypes(buildEditorTypesUrl(sandboxEndpoint)));
     return buildProjectSyncState({
         fallbackEndpoint: sandboxEndpoint,
-        fallbackInstanceId: client.instance,
         bundle,
     });
 }
@@ -35,41 +33,6 @@ export async function handleProjectCommand(context) {
     if (invocation.action === 'update') {
         throw new Error('`revo project update` is not implemented yet.');
     }
-    if (invocation.action === 'switch') {
-        if (invocation.extraArgs.length > 0) {
-            throw new Error('Project switch accepts exactly one instance ID.');
-        }
-        const instanceId = invocation.targetArg || '';
-        if (!instanceId) {
-            throw new Error('Missing instance UUID. Usage: `revo project switch <instanceId>`.');
-        }
-        if (!isUuid(instanceId)) {
-            throw new Error('Instance ID must be a UUID.');
-        }
-        const metadataFile = findProjectMetadataFile(cwd);
-        if (!metadataFile) {
-            throw new Error('Current directory is not inside an initialized Revo project.');
-        }
-        const projectRoot = resolveProjectRoot(cwd);
-        if (!projectRoot) {
-            throw new Error('Unable to resolve the current Revo project root.');
-        }
-        const storedConfigs = loadStoredConfigIndex();
-        const selected = storedConfigs.instances[instanceId];
-        if (!selected) {
-            throw new Error(`No stored credentials found for instance ${instanceId}. Run \`revo auth login --instance ${instanceId}\` first.`);
-        }
-        if (!selected.token) {
-            throw new Error(`Stored credentials for instance ${instanceId} are incomplete. Run \`revo auth login --instance ${instanceId}\` again.`);
-        }
-        client.baseUrl = selected.baseUrl;
-        client.instance = instanceId;
-        client.token = selected.token;
-        const syncInput = await resolveProjectSyncInput(context);
-        const result = syncProjectFiles(projectRoot, syncInput);
-        printSyncSummary(println, projectRoot, result, `Switched Revo project to ${instanceId} in`);
-        return;
-    }
     if (invocation.extraArgs.length > 0) {
         throw new Error('Project init accepts at most one path argument.');
     }

package/dist/src/config.d.ts

@@ -10,14 +10,8 @@ export type RuntimeConfigOptions = {
     instance?: string;
     token?: string;
 };
-type StoredConfig = RuntimeConfig;
-type StoredInstanceConfig = {
-    baseUrl: string;
-    token: string;
-};
-type StoredConfigFile = {
-    defaultInstance: string;
-    instances: Record<string, StoredInstanceConfig>;
+type StoredConfig = Omit<RuntimeConfig, 'instance'> & {
+    instance?: string;
 };
 export type AuthValidationState = {
     key: string;
@@ -37,11 +31,20 @@ export declare function readProjectInstanceId(startDir?: string): string;
 export declare function isUuid(value: unknown): value is string;
 export declare function saveStoredConfig(nextConfig: Partial<StoredConfig>): void;
 export declare function clearStoredConfig(): void;
-export declare function loadStoredConfigIndex(): StoredConfigFile;
+export declare function loadStoredConfigIndex(): {
+    defaultInstance: string;
+    instances: {
+        default: {
+            baseUrl: string;
+            token: string;
+        };
+    } | {
+        default?: undefined;
+    };
+};
 export declare function loadStoredConfig(options?: {
-    instance?: string;
     allowLegacy?: boolean;
-}): RuntimeConfig;
+}): StoredConfig;
 export declare function buildAuthValidationKey(runtime: RuntimeConfigOptions): string;
 export declare function readAuthValidationState(key?: string): AuthValidationState;
 export declare function saveAuthValidationState(state: AuthValidationState): void;

package/dist/src/config.js

@@ -73,20 +73,13 @@ export function saveStoredConfig(nextConfig) {
     const { dir, configFile, credentialsFile } = getConfigPaths();
     ensureDirectory(dir);
     const current = readStoredConfigFile();
-    const fallback = current.defaultInstance ? current.instances[current.defaultInstance] : undefined;
-    const instance = nextConfig.instance || current.defaultInstance || '';
-    if (!instance) {
-        writeJsonFile(configFile, current);
-        removeFileIfExists(credentialsFile);
-        return;
-    }
-    const currentEntry = current.instances[instance];
-    current.instances[instance] = {
-        baseUrl: nextConfig.baseUrl || currentEntry?.baseUrl || fallback?.baseUrl || DEFAULT_BASE_URL,
-        token: nextConfig.token || currentEntry?.token || fallback?.token || '',
+    const instance = nextConfig.instance || current.instance || '';
+    const config = {
+        baseUrl: nextConfig.baseUrl || current.baseUrl || DEFAULT_BASE_URL,
+        token: nextConfig.token || current.token || '',
+        ...(instance ? { instance } : {}),
     };
-    current.defaultInstance = instance;
-    writeJsonFile(configFile, current);
+    writeJsonFile(configFile, config);
     removeFileIfExists(credentialsFile);
 }
 export function clearStoredConfig() {
@@ -131,8 +124,8 @@ function migrateStoredConfigBestEffort(configFile, credentialsFile, nextConfig)
 }
 function emptyStoredConfigFile() {
     return {
-        defaultInstance: '',
-        instances: {},
+        baseUrl: DEFAULT_BASE_URL,
+        token: '',
     };
 }
 function isRecord(value) {
@@ -151,6 +144,25 @@ function normalizeInstanceConfig(value) {
         token: typeof value.token === 'string' ? value.token : '',
     };
 }
+function parseFlatConfig(raw, credentials) {
+    if (!isRecord(raw) || isRecord(raw.instances)) {
+        return null;
+    }
+    const token = typeof raw.token === 'string'
+        ? raw.token
+        : isRecord(credentials) && typeof credentials.token === 'string'
+            ? credentials.token
+            : '';
+    return {
+        baseUrl: typeof raw.baseUrl === 'string'
+            ? raw.baseUrl
+            : typeof raw.url === 'string'
+                ? raw.url
+                : DEFAULT_BASE_URL,
+        ...(typeof raw.instance === 'string' && isUuid(raw.instance) ? { instance: raw.instance } : {}),
+        token,
+    };
+}
 function parseMappedConfig(raw) {
     if (!isRecord(raw) || !isRecord(raw.instances)) {
         return null;
@@ -169,10 +181,14 @@ function parseMappedConfig(raw) {
     const defaultInstance = isUuid(configuredDefault) && instances[configuredDefault]
         ? configuredDefault
         : Object.keys(instances)[0] || '';
-    return {
-        defaultInstance,
-        instances,
-    };
+    const selected = defaultInstance ? instances[defaultInstance] : undefined;
+    return selected
+        ? {
+            baseUrl: selected.baseUrl,
+            instance: defaultInstance,
+            token: selected.token,
+        }
+        : emptyStoredConfigFile();
 }
 function parseLegacyConfig(config, credentials) {
     const baseUrl = isRecord(config) && typeof config.baseUrl === 'string'
@@ -180,58 +196,59 @@ function parseLegacyConfig(config, credentials) {
         : isRecord(config) && typeof config.url === 'string'
             ? config.url
             : DEFAULT_BASE_URL;
-    const instance = isRecord(config) && typeof config.instance === 'string' ? config.instance : '';
     const token = isRecord(credentials) && typeof credentials.token === 'string' ? credentials.token : '';
-    if (!instance) {
-        return emptyStoredConfigFile();
-    }
     return {
-        defaultInstance: instance,
-        instances: {
-            [instance]: {
-                baseUrl,
-                token,
-            },
-        },
+        baseUrl,
+        ...(isRecord(config) && typeof config.instance === 'string' && isUuid(config.instance)
+            ? { instance: config.instance }
+            : {}),
+        token,
     };
 }
 function readStoredConfigFile() {
     const { configFile, credentialsFile } = getConfigPaths();
     const config = fs.existsSync(configFile) ? readJsonFile(configFile) : {};
     const credentials = fs.existsSync(credentialsFile) ? readJsonFile(credentialsFile) : {};
-    const mapped = parseMappedConfig(config);
-    if (mapped) {
+    const flat = parseFlatConfig(config, credentials);
+    if (flat) {
         if (fs.existsSync(credentialsFile)) {
-            migrateStoredConfigBestEffort(configFile, credentialsFile, mapped);
+            migrateStoredConfigBestEffort(configFile, credentialsFile, flat);
         }
+        return flat;
+    }
+    const mapped = parseMappedConfig(config);
+    if (mapped) {
+        migrateStoredConfigBestEffort(configFile, credentialsFile, mapped);
         return mapped;
     }
     const legacy = parseLegacyConfig(config, credentials);
-    if (legacy.defaultInstance) {
+    if (legacy.token || legacy.baseUrl !== DEFAULT_BASE_URL) {
         migrateStoredConfigBestEffort(configFile, credentialsFile, legacy);
     }
     return legacy;
 }
 export function loadStoredConfigIndex() {
-    return readStoredConfigFile();
-}
-function readStoredConfig(options = {}) {
     const stored = readStoredConfigFile();
-    const selectedInstance = options.instance && stored.instances[options.instance]
-        ? options.instance
-        : stored.defaultInstance;
-    const selected = selectedInstance ? stored.instances[selectedInstance] : undefined;
     return {
-        baseUrl: selected?.baseUrl || DEFAULT_BASE_URL,
-        instance: selectedInstance || '',
-        token: selected?.token || '',
+        defaultInstance: '',
+        instances: stored.token
+            ? {
+                default: {
+                    baseUrl: stored.baseUrl,
+                    token: stored.token,
+                },
+            }
+            : {},
     };
 }
+function readStoredConfig() {
+    return readStoredConfigFile();
+}
 function mergeWithLegacy(stored, options = {}) {
     if (options.allowLegacy === false) {
         return stored;
     }
-    if ((stored.token && stored.instance) || !process.cwd()) {
+    if (stored.token || !process.cwd()) {
         return stored;
     }
     const legacy = readLegacyImportFromProject(process.cwd());
@@ -240,16 +257,15 @@ function mergeWithLegacy(stored, options = {}) {
     }
     const merged = {
         baseUrl: stored.baseUrl || legacy.baseUrl || DEFAULT_BASE_URL,
-        instance: stored.instance || options.instance || legacy.instance || '',
         token: stored.token || legacy.token || '',
     };
-    if (merged.token || merged.instance || merged.baseUrl !== DEFAULT_BASE_URL) {
+    if (merged.token || merged.baseUrl !== DEFAULT_BASE_URL) {
         saveStoredConfig(merged);
     }
     return merged;
 }
 export function loadStoredConfig(options = {}) {
-    return mergeWithLegacy(readStoredConfig(options), options);
+    return mergeWithLegacy(readStoredConfig(), options);
 }
 export function buildAuthValidationKey(runtime) {
     return createHash('sha256')
@@ -342,12 +358,7 @@ export function resolveRuntimeConfig(options = {}) {
         instance: resolveEnvValue(['REVO_INSTANCE', 'REVOENGINE_INSTANCE']),
         token: resolveEnvValue(['REVO_TOKEN', 'REVO_API_KEY', 'REVOENGINE_TOKEN', 'REVOENGINE_API_KEY']),
     };
-    const projectInstance = !options.instance && !env.instance ? readProjectInstanceId() : '';
-    const requestedInstance = options.instance || env.instance || projectInstance || undefined;
-    const stored = loadStoredConfig({
-        instance: requestedInstance,
-        allowLegacy: !requestedInstance,
-    });
+    const stored = loadStoredConfig();
     return {
         baseUrl: options.baseUrl || env.baseUrl || stored.baseUrl || DEFAULT_BASE_URL,
         instance: options.instance || env.instance || stored.instance || '',

package/dist/src/project.d.ts

@@ -11,14 +11,13 @@ export declare const REVO_DEBUG_CONFIG_FILE: string;
 export declare const REVO_PLAYGROUND_JS_FILE: string;
 export declare const REVO_PLAYGROUND_TS_FILE: string;
 export type ProjectInvocation = {
-    action: 'init' | 'switch' | 'update';
+    action: 'init' | 'update';
     targetArg?: string;
     extraArgs: string[];
 };
 export type EditorTypesBundle = {
     code: string;
     endpoint?: string;
-    instanceId?: string;
     apiVersion?: string;
     libVersion?: string;
     hash?: string;
@@ -27,7 +26,6 @@ export type EditorTypesBundle = {
 export type RevoProjectMetadata = {
     schemaVersion: 1;
     endpoint: string;
-    instanceId: string;
     authProfile: string;
     apiVersion: string;
     libVersion: string;
@@ -36,7 +34,6 @@ export type RevoProjectMetadata = {
 };
 export type ProjectSyncInput = {
     endpoint: string;
-    instanceId: string;
     code: string;
     apiVersion: string;
     libVersion: string;
@@ -60,13 +57,11 @@ export declare function buildSandboxDebugUrl(endpoint: string): string;
 export declare function extractSandboxEndpoint(profile: unknown): string | null;
 export declare function buildProjectMetadata(input: {
     baseUrl: string;
-    instance: string;
     bundle: EditorTypesBundle;
     now?: Date;
 }): {
     schemaVersion: 1;
     endpoint: string;
-    instanceId: string;
     authProfile: string;
     apiVersion: string;
     libVersion: string;
@@ -78,12 +73,10 @@ export declare function readProjectMetadata(startDir?: string): RevoProjectMetad
 export declare function resolveProjectRoot(startDir?: string): string;
 export declare function buildProjectSyncState(input: {
     fallbackEndpoint: string;
-    fallbackInstanceId: string;
     bundle: EditorTypesBundle;
     now?: Date;
 }): {
     endpoint: string;
-    instanceId: string;
     code: string;
     apiVersion: string;
     libVersion: string;

package/dist/src/project.js

@@ -192,13 +192,16 @@ export function resolveProjectInvocation(args) {
             extraArgs: [],
         };
     }
-    if (first === 'init' || first === 'switch' || first === 'update') {
+    if (first === 'init' || first === 'update') {
         return {
             action: first,
             targetArg: second,
             extraArgs: rest,
         };
     }
+    if (first === 'switch') {
+        throw new Error('`revo project switch` was removed because credentials are no longer instance-scoped.');
+    }
     return {
         action: 'init',
         targetArg: first,
@@ -221,7 +224,6 @@ export function extractEditorTypesBundle(payload) {
     return {
         code,
         endpoint: readString(root.endpoint) || readString(meta?.endpoint),
-        instanceId: readString(root.instanceId) || readString(root.instance) || readString(meta?.instanceId) || readString(meta?.instance),
         apiVersion: readString(root.apiVersion) || readString(meta?.apiVersion),
         libVersion: readString(root.libVersion) || readString(meta?.libVersion),
         hash: readString(root.hash) || readString(meta?.hash),
@@ -265,27 +267,27 @@ export function extractSandboxEndpoint(profile) {
         roots.push(nestedProfile);
     }
     for (const root of roots) {
-        const instance = root.instance;
-        if (!instance || typeof instance !== 'object' || Array.isArray(instance)) {
-            continue;
-        }
-        const endpoints = instance.endpoints;
-        if (!endpoints || typeof endpoints !== 'object' || Array.isArray(endpoints)) {
-            continue;
-        }
-        const sandbox = endpoints.sandbox;
-        if (typeof sandbox === 'string' && sandbox) {
-            return normalizeEndpoint(sandbox);
+        const endpointContainers = [
+            root.endpoints,
+            isRecord(root.instance) ? root.instance.endpoints : null,
+        ];
+        for (const endpoints of endpointContainers) {
+            if (!isRecord(endpoints)) {
+                continue;
+            }
+            const sandbox = endpoints.sandbox;
+            if (typeof sandbox === 'string' && sandbox) {
+                return normalizeEndpoint(sandbox);
+            }
         }
     }
     return null;
 }
 export function buildProjectMetadata(input) {
-    const { baseUrl, bundle, instance, now = new Date() } = input;
+    const { baseUrl, bundle, now = new Date() } = input;
     return {
         schemaVersion: 1,
         endpoint: bundle.endpoint || buildEditorEndpoint(baseUrl),
-        instanceId: bundle.instanceId || instance,
         authProfile: 'default',
         apiVersion: getRequiredMetadataValue(bundle, 'apiVersion'),
         libVersion: getRequiredMetadataValue(bundle, 'libVersion'),
@@ -319,8 +321,7 @@ export function readProjectMetadata(startDir = process.cwd()) {
     if (!isRecord(raw)) {
         return null;
     }
-    if (typeof raw.instanceId !== 'string'
-        || typeof raw.endpoint !== 'string'
+    if (typeof raw.endpoint !== 'string'
         || typeof raw.authProfile !== 'string'
         || typeof raw.apiVersion !== 'string'
         || typeof raw.libVersion !== 'string'
@@ -337,13 +338,11 @@ export function resolveProjectRoot(startDir = process.cwd()) {
 export function buildProjectSyncState(input) {
     const metadata = buildProjectMetadata({
         baseUrl: input.fallbackEndpoint,
-        instance: input.fallbackInstanceId,
         bundle: input.bundle,
         now: input.now,
     });
     return {
         endpoint: metadata.endpoint,
-        instanceId: metadata.instanceId,
         code: input.bundle.code,
         apiVersion: metadata.apiVersion,
         libVersion: metadata.libVersion,
@@ -362,7 +361,6 @@ export function syncProjectFiles(targetDir, input) {
     writeJsonFile(metadataFile, {
         schemaVersion: 1,
         endpoint: input.endpoint,
-        instanceId: input.instanceId,
         authProfile: 'default',
         apiVersion: input.apiVersion,
         libVersion: input.libVersion,

package/dist/src/runtime-view.js

@@ -49,9 +49,9 @@ export async function buildRuntimeViewModel(context, options = {}) {
         validation: null,
         email: null,
     };
-    if (runtime.token && runtime.instance) {
+    if (runtime.token) {
         context.client.baseUrl = runtime.baseUrl;
-        context.client.instance = runtime.instance;
+        context.client.instance = runtime.instance || '';
         context.client.token = runtime.token;
         try {
             const profile = await context.client.me({ force: options.forceValidation });

package/dist/src/ui.js

@@ -95,16 +95,15 @@ function renderCommandCatalog() {
         '',
         paintHeader('Global Options'),
         commandRow('--url <url>', 'Override API base URL for TEST, prod, local, or dedicated tenants'),
-        commandRow('--instance <uuid>', 'Override instance ID'),
         commandRow('--token <apiKey>', 'Override API key for non-interactive runs'),
+        commandRow('--no-update-notifier', 'Disable npm version update checks for this run'),
         '',
         paintHeader('Core'),
         commandRow('revo -i', 'Show runtime info, config path, and auth state'),
-        commandRow('revo auth login', 'Paste API key and instance ID in the terminal'),
+        commandRow('revo auth login', 'Paste API key in the terminal'),
         commandRow('revo auth status', 'Show the current authentication status'),
         commandRow('revo auth logout', 'Remove stored credentials'),
         commandRow('revo project [path]', 'Initialize ambient editor types for JS and TS'),
-        commandRow('revo project switch <instanceId>', 'Switch the current project to another stored instance'),
         commandRow('revo endpoints', 'List available API endpoints'),
         '',
         paintHeader('Components'),
@@ -153,7 +152,6 @@ export function renderRuntimeInfo(input) {
         row('Config', configDir),
         row('Base URL', runtime.baseUrl),
         row('Status', formatStatusValue(auth)),
-        row('Instance', runtime.instance || 'missing'),
         ...(shouldRenderValidationRow(auth) ? [row('Validation', auth.validation || 'skipped')] : []),
         '',
         paintHeader('Tips'),
@@ -168,7 +166,6 @@ export function renderAuthStatus(input) {
         row('Status', formatStatusValue(auth)),
         row('Config', configDir),
         row('Base URL', runtime.baseUrl),
-        row('Instance', runtime.instance || 'missing'),
         row('API key', runtime.token ? 'configured' : 'missing'),
         ...(shouldRenderValidationRow(auth) ? [row('Validation', auth.validation || 'skipped')] : []),
     ].join('\n');

package/dist/src/update-notifier.d.ts

@@ -0,0 +1,16 @@
+import type { ParsedArgs } from './types.ts';
+type UpdateNotifierOptions = {
+    args?: ParsedArgs;
+    currentVersion: string;
+    fetch?: typeof fetch;
+    now?: number;
+    stream?: NodeJS.WriteStream;
+};
+export declare function compareSemver(left: string, right: string): 0 | 1 | -1;
+export declare function renderUpdateNotice(input: {
+    currentVersion: string;
+    latestVersion: string;
+    stream?: NodeJS.WriteStream;
+}): string;
+export declare function maybeNotifyUpdateAvailable(options: UpdateNotifierOptions): Promise<void>;
+export {};

package/dist/src/update-notifier.js

@@ -0,0 +1,142 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getConfigDir } from "./config.js";
+import { CLI_NAME, CLI_PACKAGE } from "./ui.js";
+import { readJsonFile, writeJsonFile } from "./utils.js";
+const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 1_000;
+const UPDATE_STATE_FILE = 'update-state.json';
+const NPM_PACKAGE_URL = `https://registry.npmjs.org/${encodeURIComponent(CLI_PACKAGE)}/latest`;
+function isTruthyEnv(value) {
+    return value === '1' || value === 'true' || value === 'yes';
+}
+function updateNotifierDisabled(args) {
+    return Boolean(args?.['no-update-notifier'])
+        || isTruthyEnv(process.env.REVO_NO_UPDATE_NOTIFIER)
+        || isTruthyEnv(process.env.NO_UPDATE_NOTIFIER)
+        || isTruthyEnv(process.env.CI);
+}
+function getUpdateStatePath() {
+    return path.join(getConfigDir(), UPDATE_STATE_FILE);
+}
+function readUpdateState() {
+    const filePath = getUpdateStatePath();
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const raw = readJsonFile(filePath);
+        if (raw
+            && typeof raw === 'object'
+            && !Array.isArray(raw)
+            && typeof raw.checkedAt === 'number'
+            && typeof raw.latestVersion === 'string') {
+            return raw;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function saveUpdateState(state) {
+    try {
+        writeJsonFile(getUpdateStatePath(), state);
+    }
+    catch {
+        // Update checks are advisory and must never make a CLI command fail.
+    }
+}
+function parseVersion(version) {
+    const match = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+    if (!match) {
+        return null;
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+export function compareSemver(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) {
+        return 0;
+    }
+    for (let index = 0; index < parsedLeft.length; index += 1) {
+        if (parsedLeft[index] > parsedRight[index]) {
+            return 1;
+        }
+        if (parsedLeft[index] < parsedRight[index]) {
+            return -1;
+        }
+    }
+    return 0;
+}
+async function fetchLatestVersion(fetchImpl) {
+    const response = await fetchImpl(NPM_PACKAGE_URL, {
+        headers: {
+            accept: 'application/json',
+        },
+        signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        return '';
+    }
+    const data = await response.json();
+    return data && typeof data === 'object' && typeof data.version === 'string'
+        ? data.version
+        : '';
+}
+function supportsColor(stream) {
+    return Boolean(stream.isTTY || process.env.FORCE_COLOR);
+}
+function color(stream, text, code) {
+    return supportsColor(stream) ? `${code}${text}\u001b[0m` : text;
+}
+export function renderUpdateNotice(input) {
+    const stream = input.stream || process.stderr;
+    const yellow = '\u001b[33m';
+    const cyan = '\u001b[36m';
+    const bold = '\u001b[1m';
+    return [
+        color(stream, `Update available ${input.currentVersion} -> ${input.latestVersion}`, bold + yellow),
+        `Run ${color(stream, `npm install -g ${CLI_PACKAGE}`, cyan)} to update ${CLI_NAME}.`,
+    ].join('\n');
+}
+export async function maybeNotifyUpdateAvailable(options) {
+    const stream = options.stream || process.stderr;
+    const fetchImpl = options.fetch || globalThis.fetch;
+    const now = options.now || Date.now();
+    if (updateNotifierDisabled(options.args) || !stream.isTTY || !fetchImpl) {
+        return;
+    }
+    const cached = readUpdateState();
+    if (cached && now - cached.checkedAt < UPDATE_CHECK_TTL_MS) {
+        if (compareSemver(cached.latestVersion, options.currentVersion) > 0) {
+            stream.write(`${renderUpdateNotice({
+                currentVersion: options.currentVersion,
+                latestVersion: cached.latestVersion,
+                stream,
+            })}\n`);
+        }
+        return;
+    }
+    try {
+        const latestVersion = await fetchLatestVersion(fetchImpl);
+        if (!latestVersion) {
+            return;
+        }
+        saveUpdateState({
+            checkedAt: now,
+            latestVersion,
+        });
+        if (compareSemver(latestVersion, options.currentVersion) > 0) {
+            stream.write(`${renderUpdateNotice({
+                currentVersion: options.currentVersion,
+                latestVersion,
+                stream,
+            })}\n`);
+        }
+    }
+    catch {
+        // Network, registry, and cache failures must not affect the requested command.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revoengine/cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "CLI package for the RevoEngine Platform API",
   "type": "module",
   "main": "dist/src/index.js",
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "check": "node --input-type=module -e \"await import('./src/config.ts'); await import('./src/legacy.ts'); await import('./src/client.ts'); await import('./src/ui.ts'); await import('./src/commands/auth.ts'); await import('./src/commands/component.ts'); await import('./src/commands/endpoints.ts'); await import('./src/commands/info.ts'); await import('./src/commands/request.ts'); await import('./src/commands/search.ts'); await import('./src/cli.ts'); await import('./src/index.ts'); await import('./bin/revo.ts'); await import('./scripts/dev.ts')\"",
+    "check": "node --input-type=module -e \"await import('./src/config.ts'); await import('./src/legacy.ts'); await import('./src/client.ts'); await import('./src/ui.ts'); await import('./src/update-notifier.ts'); await import('./src/commands/auth.ts'); await import('./src/commands/component.ts'); await import('./src/commands/endpoints.ts'); await import('./src/commands/info.ts'); await import('./src/commands/request.ts'); await import('./src/commands/search.ts'); await import('./src/cli.ts'); await import('./src/index.ts'); await import('./bin/revo.ts'); await import('./scripts/dev.ts')\"",
     "dev": "node ./scripts/dev.ts",
     "prepack": "npm run build",
     "test": "node --test ./test/*.test.ts"