@revoengine/cli 1.0.1 → 1.0.3

package/README.md

@@ -29,6 +29,8 @@ revo auth login
 
 `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:
 
 ```bash
@@ -134,11 +136,13 @@ 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.
+- 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`.

package/dist/src/cli.js

@@ -138,6 +138,7 @@ function printError(error) {
 function resolveClient(args) {
     const runtime = resolveRuntimeConfig({
         baseUrl: typeof args.url === 'string' ? args.url : typeof args.baseUrl === 'string' ? args.baseUrl : undefined,
+        instance: typeof args.instance === 'string' ? args.instance : typeof args.i === 'string' ? args.i : undefined,
         token: typeof args.token === 'string' ? args.token : typeof args.t === 'string' ? args.t : undefined,
     });
     return new RevoClient(runtime);

package/dist/src/client.d.ts

@@ -11,6 +11,7 @@ export type ComponentListRequest = {
 };
 export type ClientOptions = {
     baseUrl?: string;
+    instance?: string;
     token?: string;
     fetch?: typeof fetch;
 };
@@ -34,8 +35,10 @@ 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;
     token: string;
     fetchImpl: typeof fetch | undefined;
     constructor(options?: ClientOptions);
@@ -64,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

@@ -125,13 +125,39 @@ 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;
     token;
     fetchImpl;
     constructor(options = {}) {
         const config = resolveRuntimeConfig(options);
         this.baseUrl = config.baseUrl;
+        this.instance = config.instance || '';
         this.token = config.token;
         this.fetchImpl = options.fetch || globalThis.fetch;
     }
@@ -141,6 +167,7 @@ export class RevoClient {
     get authValidationKey() {
         return buildAuthValidationKey({
             baseUrl: this.baseUrl,
+            instance: this.instance,
             token: this.token,
         });
     }
@@ -164,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,
@@ -173,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',
@@ -206,6 +235,10 @@ export class RevoClient {
         const headers = new Headers(options.headers || {});
         headers.set('Authorization', this.authHeader);
         headers.set('x-api-key', this.token);
+        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');
@@ -294,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

@@ -62,6 +62,7 @@ export async function handleAuthCommand(context) {
         println(`Imported legacy config from ${filePath}.`);
         if (!offline) {
             client.token = imported.token;
+            client.instance = imported.instance;
             client.baseUrl = imported.baseUrl;
             if (imported.token) {
                 try {
@@ -99,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

@@ -1,11 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { ApiError, PermissionDeniedError } from "../client.js";
-import { buildSandboxDebugUrl, extractSandboxEndpoint } from "../project.js";
+import { buildSandboxDebugUrl, extractSandboxEndpoint, resolveProjectWorkspace } 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',
@@ -188,7 +192,8 @@ function normalizeComponentType(component) {
     return 'CODE_JS';
 }
 function getWorkspaceRoot(cwd) {
-    return path.join(cwd, 'Components');
+    const projectWorkspace = resolveProjectWorkspace(cwd);
+    return path.join(projectWorkspace || cwd, 'Components');
 }
 function getCategoryFolder(component) {
     if (component.category == null || component.category === '') {
@@ -202,23 +207,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 +339,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 +580,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 +610,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 +658,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 +711,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;
         }

package/dist/src/config.d.ts

@@ -2,13 +2,15 @@ export declare const APP_NAME = "revoengine";
 export declare const DEFAULT_BASE_URL = "https://api.revoengine.com";
 export type RuntimeConfig = {
     baseUrl: string;
+    instance: string;
     token: string;
 };
 export type RuntimeConfigOptions = {
     baseUrl?: string;
+    instance?: string;
     token?: string;
 };
-type LegacyRuntimeConfig = RuntimeConfig & {
+type StoredConfig = Omit<RuntimeConfig, 'instance'> & {
     instance?: string;
 };
 export type AuthValidationState = {
@@ -27,7 +29,7 @@ export declare function getConfigPaths(): {
 };
 export declare function readProjectInstanceId(startDir?: string): string;
 export declare function isUuid(value: unknown): value is string;
-export declare function saveStoredConfig(nextConfig: Partial<LegacyRuntimeConfig>): void;
+export declare function saveStoredConfig(nextConfig: Partial<StoredConfig>): void;
 export declare function clearStoredConfig(): void;
 export declare function loadStoredConfigIndex(): {
     defaultInstance: string;
@@ -42,13 +44,14 @@ export declare function loadStoredConfigIndex(): {
 };
 export declare function loadStoredConfig(options?: {
     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;
 export declare function clearAuthValidationState(key?: string): void;
 export declare function resolveRuntimeConfig(options?: RuntimeConfigOptions): {
     baseUrl: string;
+    instance: string;
     token: string;
 };
 export {};

package/dist/src/config.js

@@ -73,10 +73,13 @@ export function saveStoredConfig(nextConfig) {
     const { dir, configFile, credentialsFile } = getConfigPaths();
     ensureDirectory(dir);
     const current = readStoredConfigFile();
-    writeJsonFile(configFile, {
+    const instance = nextConfig.instance || current.instance || '';
+    const config = {
         baseUrl: nextConfig.baseUrl || current.baseUrl || DEFAULT_BASE_URL,
         token: nextConfig.token || current.token || '',
-    });
+        ...(instance ? { instance } : {}),
+    };
+    writeJsonFile(configFile, config);
     removeFileIfExists(credentialsFile);
 }
 export function clearStoredConfig() {
@@ -156,6 +159,7 @@ function parseFlatConfig(raw, credentials) {
             : typeof raw.url === 'string'
                 ? raw.url
                 : DEFAULT_BASE_URL,
+        ...(typeof raw.instance === 'string' && isUuid(raw.instance) ? { instance: raw.instance } : {}),
         token,
     };
 }
@@ -181,6 +185,7 @@ function parseMappedConfig(raw) {
     return selected
         ? {
             baseUrl: selected.baseUrl,
+            instance: defaultInstance,
             token: selected.token,
         }
         : emptyStoredConfigFile();
@@ -194,6 +199,9 @@ function parseLegacyConfig(config, credentials) {
     const token = isRecord(credentials) && typeof credentials.token === 'string' ? credentials.token : '';
     return {
         baseUrl,
+        ...(isRecord(config) && typeof config.instance === 'string' && isUuid(config.instance)
+            ? { instance: config.instance }
+            : {}),
         token,
     };
 }
@@ -263,6 +271,7 @@ export function buildAuthValidationKey(runtime) {
     return createHash('sha256')
         .update(JSON.stringify({
         baseUrl: runtime.baseUrl || DEFAULT_BASE_URL,
+        instance: runtime.instance || '',
         token: runtime.token || '',
     }))
         .digest('hex');
@@ -346,11 +355,13 @@ export function clearAuthValidationState(key) {
 export function resolveRuntimeConfig(options = {}) {
     const env = {
         baseUrl: resolveEnvValue(['REVO_URL', 'REVO_BASE_URL', 'REVOENGINE_URL', 'REVOENGINE_BASE_URL']),
+        instance: resolveEnvValue(['REVO_INSTANCE', 'REVOENGINE_INSTANCE']),
         token: resolveEnvValue(['REVO_TOKEN', 'REVO_API_KEY', 'REVOENGINE_TOKEN', 'REVOENGINE_API_KEY']),
     };
     const stored = loadStoredConfig();
     return {
         baseUrl: options.baseUrl || env.baseUrl || stored.baseUrl || DEFAULT_BASE_URL,
+        instance: options.instance || env.instance || stored.instance || '',
         token: options.token || env.token || stored.token || '',
     };
 }

package/dist/src/project.d.ts

@@ -3,6 +3,7 @@ export declare const REVO_PROJECT_DIR = ".revoengine";
 export declare const REVO_TYPES_DIR: string;
 export declare const REVO_TYPES_FILE: string;
 export declare const REVO_METADATA_FILE: string;
+export declare const REVO_VSCODE_CONFIG_FILE: string;
 export declare const REVO_TYPES_GITIGNORE_ENTRY = ".revoengine/types/";
 export declare const REVO_DEBUG_JS_FILE: string;
 export declare const REVO_DEBUG_TS_FILE: string;
@@ -31,6 +32,7 @@ export type RevoProjectMetadata = {
     libVersion: string;
     hash: string;
     lastSyncAt: string;
+    workspace?: string;
 };
 export type ProjectSyncInput = {
     endpoint: string;
@@ -71,6 +73,7 @@ export declare function buildProjectMetadata(input: {
 export declare function findProjectMetadataFile(startDir?: string): string;
 export declare function readProjectMetadata(startDir?: string): RevoProjectMetadata | null;
 export declare function resolveProjectRoot(startDir?: string): string;
+export declare function resolveProjectWorkspace(startDir?: string): string;
 export declare function buildProjectSyncState(input: {
     fallbackEndpoint: string;
     bundle: EditorTypesBundle;

package/dist/src/project.js

@@ -5,6 +5,7 @@ export const REVO_PROJECT_DIR = '.revoengine';
 export const REVO_TYPES_DIR = path.join(REVO_PROJECT_DIR, 'types');
 export const REVO_TYPES_FILE = path.join(REVO_TYPES_DIR, 'revo.editor.d.ts');
 export const REVO_METADATA_FILE = path.join(REVO_PROJECT_DIR, 'revo.json');
+export const REVO_VSCODE_CONFIG_FILE = path.join(REVO_PROJECT_DIR, 'vscode.json');
 export const REVO_TYPES_GITIGNORE_ENTRY = '.revoengine/types/';
 export const REVO_DEBUG_JS_FILE = path.join(REVO_PROJECT_DIR, 'debug_code.js');
 export const REVO_DEBUG_TS_FILE = path.join(REVO_PROJECT_DIR, 'debug_code.ts');
@@ -335,6 +336,38 @@ export function resolveProjectRoot(startDir = process.cwd()) {
     const metadataFile = findProjectMetadataFile(startDir);
     return metadataFile ? path.dirname(path.dirname(metadataFile)) : '';
 }
+function readWorkspaceDirectoryFromProjectConfig(projectRoot, metadata) {
+    const vscodeConfigPath = path.join(projectRoot, REVO_VSCODE_CONFIG_FILE);
+    if (fs.existsSync(vscodeConfigPath)) {
+        const config = parseConfigFile(vscodeConfigPath);
+        const workspaceDirectory = readString(config.workspaceDirectory);
+        if (workspaceDirectory) {
+            return workspaceDirectory;
+        }
+    }
+    return readString(metadata.workspace) || '';
+}
+function resolveProjectWorkspaceRoot(projectRoot, workspaceDirectory) {
+    const resolved = path.resolve(projectRoot, workspaceDirectory || '.');
+    const relative = path.relative(projectRoot, resolved);
+    if (relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))) {
+        return resolved;
+    }
+    throw new Error('Project workspace directory must stay inside the Revo project root.');
+}
+export function resolveProjectWorkspace(startDir = process.cwd()) {
+    const metadataFile = findProjectMetadataFile(startDir);
+    if (!metadataFile) {
+        return '';
+    }
+    const projectRoot = path.dirname(path.dirname(metadataFile));
+    const raw = readJsonFile(metadataFile);
+    if (!isRecord(raw)) {
+        return projectRoot;
+    }
+    const workspaceDirectory = readWorkspaceDirectoryFromProjectConfig(projectRoot, raw);
+    return resolveProjectWorkspaceRoot(projectRoot, workspaceDirectory);
+}
 export function buildProjectSyncState(input) {
     const metadata = buildProjectMetadata({
         baseUrl: input.fallbackEndpoint,

package/dist/src/runtime-view.js

@@ -7,6 +7,11 @@ function resolveArgsRuntime(context) {
             : typeof context.args.baseUrl === 'string'
                 ? context.args.baseUrl
                 : undefined,
+        instance: typeof context.args.instance === 'string'
+            ? context.args.instance
+            : typeof context.args.i === 'string'
+                ? context.args.i
+                : undefined,
         token: typeof context.args.token === 'string'
             ? context.args.token
             : typeof context.args.t === 'string'
@@ -46,6 +51,7 @@ export async function buildRuntimeViewModel(context, options = {}) {
     };
     if (runtime.token) {
         context.client.baseUrl = runtime.baseUrl;
+        context.client.instance = runtime.instance || '';
         context.client.token = runtime.token;
         try {
             const profile = await context.client.me({ force: options.forceValidation });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revoengine/cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "CLI package for the RevoEngine Platform API",
   "type": "module",
   "main": "dist/src/index.js",