@revoengine/cli 1.0.0

package/dist/src/legacy.js

@@ -0,0 +1,88 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_BASE_URL } from "./config.js";
+import { readJsonFile } from "./utils.js";
+function isLegacyAccountRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function resolveLegacyEntry(configFile, preferredInstance) {
+    if (preferredInstance && isLegacyAccountRecord(configFile[preferredInstance])) {
+        return [preferredInstance, configFile[preferredInstance]];
+    }
+    for (const [key, value] of Object.entries(configFile)) {
+        if (isLegacyAccountRecord(value) && value.default) {
+            return [key, value];
+        }
+    }
+    for (const [key, value] of Object.entries(configFile)) {
+        if (isLegacyAccountRecord(value)) {
+            return [key, value];
+        }
+    }
+    return undefined;
+}
+function normalizeLegacyRecord(record, fallbackInstance = '') {
+    const baseUrl = record.url || record.baseUrl || DEFAULT_BASE_URL;
+    const instance = record.instance || fallbackInstance;
+    const token = record.token || record.key || '';
+    return {
+        baseUrl,
+        instance,
+        token,
+        source: 'legacy-config',
+    };
+}
+export function readLegacyImportFromFile(filePath, preferredInstance) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = readJsonFile(filePath);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return null;
+    }
+    if (isLegacyAccountRecord(parsed)) {
+        return normalizeLegacyRecord(parsed, preferredInstance || parsed.instance || '');
+    }
+    const selected = resolveLegacyEntry(parsed, preferredInstance);
+    if (!selected) {
+        return null;
+    }
+    const [instanceKey, record] = selected;
+    return normalizeLegacyRecord(record, record.instance || instanceKey);
+}
+export function readLegacyImportFromProject(cwd = process.cwd()) {
+    const projectStatePath = path.join(cwd, '.revongcli');
+    if (!fs.existsSync(projectStatePath)) {
+        return null;
+    }
+    const projectState = readJsonFile(projectStatePath);
+    const credentials = projectState?.credentials || '';
+    if (credentials === 'ENVIRONMENTAL_VARIABLES') {
+        const envConfig = process.env.REVO_CONFIG;
+        if (!envConfig) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(envConfig);
+            const selected = resolveLegacyEntry(parsed, projectState.instance || undefined);
+            if (!selected) {
+                return null;
+            }
+            const [instanceKey, record] = selected;
+            return normalizeLegacyRecord(record, projectState.instance || record.instance || instanceKey);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!credentials) {
+        return null;
+    }
+    return readLegacyImportFromFile(credentials, projectState.instance || undefined);
+}

package/dist/src/project.d.ts

@@ -0,0 +1,102 @@
+import type { ParsedArgs } from './types.ts';
+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_TYPES_GITIGNORE_ENTRY = ".revoengine/types/";
+export declare const REVO_DEBUG_JS_FILE: string;
+export declare const REVO_DEBUG_TS_FILE: string;
+export declare const REVO_DEBUG_INPUT_FILE: string;
+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';
+    targetArg?: string;
+    extraArgs: string[];
+};
+export type EditorTypesBundle = {
+    code: string;
+    endpoint?: string;
+    instanceId?: string;
+    apiVersion?: string;
+    libVersion?: string;
+    hash?: string;
+    lastSyncAt?: string;
+};
+export type RevoProjectMetadata = {
+    schemaVersion: 1;
+    endpoint: string;
+    instanceId: string;
+    authProfile: string;
+    apiVersion: string;
+    libVersion: string;
+    hash: string;
+    lastSyncAt: string;
+};
+export type ProjectSyncInput = {
+    endpoint: string;
+    instanceId: string;
+    code: string;
+    apiVersion: string;
+    libVersion: string;
+    hash: string;
+    lastSyncAt: string;
+};
+export type ProjectConfigResult = {
+    filePath: string;
+    action: 'created' | 'patched';
+};
+export type GitignorePatchResult = {
+    filePath: string;
+    action: 'created' | 'patched' | 'unchanged';
+};
+export declare function resolveProjectInvocation(args: ParsedArgs): ProjectInvocation;
+export declare function resolveProjectTarget(cwd: string, targetArg?: string): string;
+export declare function extractEditorTypesBundle(payload: unknown): EditorTypesBundle;
+export declare function buildEditorEndpoint(baseUrl: string): string;
+export declare function buildEditorTypesUrl(endpoint: string): string;
+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;
+    hash: string;
+    lastSyncAt: string;
+};
+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 buildProjectSyncState(input: {
+    fallbackEndpoint: string;
+    fallbackInstanceId: string;
+    bundle: EditorTypesBundle;
+    now?: Date;
+}): {
+    endpoint: string;
+    instanceId: string;
+    code: string;
+    apiVersion: string;
+    libVersion: string;
+    hash: string;
+    lastSyncAt: string;
+};
+export declare function syncProjectFiles(targetDir: string, input: ProjectSyncInput): {
+    projectDir: string;
+    typesFile: string;
+    metadataFile: string;
+    configResult: ProjectConfigResult;
+    gitignoreResult: GitignorePatchResult;
+};
+export declare function ensureProjectDebugScaffolding(rootDir: string): void;
+export declare function ensureProjectConfig(rootDir: string): ProjectConfigResult;
+export declare function ensureProjectGitignore(rootDir: string): GitignorePatchResult;

package/dist/src/project.js

@@ -0,0 +1,475 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJsonFile } from "./utils.js";
+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_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');
+export const REVO_DEBUG_INPUT_FILE = path.join(REVO_PROJECT_DIR, 'debug_input.json');
+export const REVO_DEBUG_CONFIG_FILE = path.join(REVO_PROJECT_DIR, 'debug.json');
+export const REVO_PLAYGROUND_JS_FILE = path.join(REVO_PROJECT_DIR, 'playground_code.js');
+export const REVO_PLAYGROUND_TS_FILE = path.join(REVO_PROJECT_DIR, 'playground_code.ts');
+const DEFAULT_PROJECT_INCLUDE = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+    REVO_TYPES_FILE,
+];
+const DEFAULT_PROJECT_EXCLUDE = [
+    'node_modules',
+    'dist',
+    'build',
+];
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function getNestedRecord(record, key) {
+    const candidate = record[key];
+    return isRecord(candidate) ? candidate : undefined;
+}
+function getRequiredMetadataValue(bundle, key) {
+    const value = bundle[key];
+    if (!value) {
+        throw new Error(`Editor types response did not include \`${key}\`.`);
+    }
+    return value;
+}
+function normalizeEndpoint(value) {
+    return value.replace(/\/+$/, '');
+}
+function stripJsonComments(input) {
+    let output = '';
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        const next = input[index + 1];
+        if (inLineComment) {
+            if (char === '\n' || char === '\r') {
+                inLineComment = false;
+                output += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && next === '/') {
+                inBlockComment = false;
+                index += 1;
+                continue;
+            }
+            if (char === '\n' || char === '\r') {
+                output += char;
+            }
+            continue;
+        }
+        if (inString) {
+            output += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            output += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        output += char;
+    }
+    return output;
+}
+function stripTrailingCommas(input) {
+    let output = '';
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        if (inString) {
+            output += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            output += char;
+            continue;
+        }
+        if (char === ',') {
+            let lookahead = index + 1;
+            while (lookahead < input.length && /\s/.test(input[lookahead])) {
+                lookahead += 1;
+            }
+            if (input[lookahead] === '}' || input[lookahead] === ']') {
+                continue;
+            }
+        }
+        output += char;
+    }
+    return output;
+}
+function parseConfigFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) {
+        return {};
+    }
+    const normalized = stripTrailingCommas(stripJsonComments(raw));
+    const parsed = JSON.parse(normalized);
+    if (!isRecord(parsed)) {
+        throw new Error(`${path.basename(filePath)} must contain a JSON object.`);
+    }
+    return parsed;
+}
+function ensureObjectField(target, key, filePath) {
+    const current = target[key];
+    if (current === undefined) {
+        const next = {};
+        target[key] = next;
+        return next;
+    }
+    if (!isRecord(current)) {
+        throw new Error(`${path.basename(filePath)} field \`${key}\` must be an object.`);
+    }
+    return current;
+}
+function ensureStringArray(value, field, filePath) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`${path.basename(filePath)} field \`${field}\` must be an array of strings.`);
+    }
+    return [...value];
+}
+function appendUnique(list, value) {
+    if (!list.includes(value)) {
+        list.push(value);
+    }
+    return list;
+}
+function writeJsonFile(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function resolveProjectInvocation(args) {
+    const projectArgs = args._.slice(1);
+    const [first, second, ...rest] = projectArgs;
+    if (!first) {
+        return {
+            action: 'init',
+            extraArgs: [],
+        };
+    }
+    if (first === 'init' || first === 'switch' || first === 'update') {
+        return {
+            action: first,
+            targetArg: second,
+            extraArgs: rest,
+        };
+    }
+    return {
+        action: 'init',
+        targetArg: first,
+        extraArgs: second ? [second, ...rest] : rest,
+    };
+}
+export function resolveProjectTarget(cwd, targetArg) {
+    return path.resolve(cwd, targetArg || '.');
+}
+export function extractEditorTypesBundle(payload) {
+    const root = isRecord(payload) && isRecord(payload.data) ? payload.data : payload;
+    if (!isRecord(root)) {
+        throw new Error('Editor types response was not a JSON object.');
+    }
+    const meta = getNestedRecord(root, 'meta');
+    const code = readString(root.code);
+    if (!code) {
+        throw new Error('Editor types response did not include a `code` field.');
+    }
+    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),
+        lastSyncAt: readString(root.lastSyncAt) || readString(meta?.lastSyncAt),
+    };
+}
+export function buildEditorEndpoint(baseUrl) {
+    const url = new URL(baseUrl);
+    const basePath = url.pathname.replace(/\/+$/, '');
+    url.pathname = (/\/v\d+$/i.test(basePath) ? basePath : `${basePath || ''}/v1`).replace(/\/{2,}/g, '/');
+    url.search = '';
+    url.hash = '';
+    return normalizeEndpoint(url.toString());
+}
+export function buildEditorTypesUrl(endpoint) {
+    const url = new URL(endpoint);
+    const basePath = normalizeEndpoint(url.pathname);
+    const versionedPath = /\/v\d+$/i.test(basePath) ? basePath : `${basePath || ''}/v1`;
+    url.pathname = `${versionedPath}/editor/types`.replace(/\/{2,}/g, '/');
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+}
+export function buildSandboxDebugUrl(endpoint) {
+    const url = new URL(endpoint);
+    const basePath = normalizeEndpoint(url.pathname);
+    const versionedPath = /\/v\d+$/i.test(basePath) ? basePath : `${basePath || ''}/v1`;
+    url.pathname = `${versionedPath}/debug`.replace(/\/{2,}/g, '/');
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+}
+export function extractSandboxEndpoint(profile) {
+    if (!profile || typeof profile !== 'object') {
+        return null;
+    }
+    const candidate = profile;
+    const roots = [candidate];
+    const nestedProfile = candidate.profile;
+    if (nestedProfile && typeof nestedProfile === 'object' && !Array.isArray(nestedProfile)) {
+        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);
+        }
+    }
+    return null;
+}
+export function buildProjectMetadata(input) {
+    const { baseUrl, bundle, instance, 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'),
+        hash: getRequiredMetadataValue(bundle, 'hash'),
+        lastSyncAt: bundle.lastSyncAt || now.toISOString(),
+    };
+}
+export function findProjectMetadataFile(startDir = process.cwd()) {
+    if (!startDir) {
+        return '';
+    }
+    let currentDir = path.resolve(startDir);
+    const { root } = path.parse(currentDir);
+    while (true) {
+        const candidate = path.join(currentDir, REVO_METADATA_FILE);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        if (currentDir === root) {
+            return '';
+        }
+        currentDir = path.dirname(currentDir);
+    }
+}
+export function readProjectMetadata(startDir = process.cwd()) {
+    const metadataFile = findProjectMetadataFile(startDir);
+    if (!metadataFile) {
+        return null;
+    }
+    const raw = readJsonFile(metadataFile);
+    if (!isRecord(raw)) {
+        return null;
+    }
+    if (typeof raw.instanceId !== 'string'
+        || typeof raw.endpoint !== 'string'
+        || typeof raw.authProfile !== 'string'
+        || typeof raw.apiVersion !== 'string'
+        || typeof raw.libVersion !== 'string'
+        || typeof raw.hash !== 'string'
+        || typeof raw.lastSyncAt !== 'string') {
+        return null;
+    }
+    return raw;
+}
+export function resolveProjectRoot(startDir = process.cwd()) {
+    const metadataFile = findProjectMetadataFile(startDir);
+    return metadataFile ? path.dirname(path.dirname(metadataFile)) : '';
+}
+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,
+        hash: metadata.hash,
+        lastSyncAt: metadata.lastSyncAt,
+    };
+}
+export function syncProjectFiles(targetDir, input) {
+    const projectDir = path.join(targetDir, REVO_PROJECT_DIR);
+    const typesDir = path.join(targetDir, REVO_TYPES_DIR);
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(typesDir, { recursive: true });
+    const typesFile = path.join(targetDir, REVO_TYPES_FILE);
+    const metadataFile = path.join(targetDir, REVO_METADATA_FILE);
+    fs.writeFileSync(typesFile, input.code);
+    writeJsonFile(metadataFile, {
+        schemaVersion: 1,
+        endpoint: input.endpoint,
+        instanceId: input.instanceId,
+        authProfile: 'default',
+        apiVersion: input.apiVersion,
+        libVersion: input.libVersion,
+        hash: input.hash,
+        lastSyncAt: input.lastSyncAt,
+    });
+    const configResult = ensureProjectConfig(targetDir);
+    const gitignoreResult = ensureProjectGitignore(targetDir);
+    ensureProjectDebugScaffolding(targetDir);
+    return {
+        projectDir,
+        typesFile,
+        metadataFile,
+        configResult,
+        gitignoreResult,
+    };
+}
+export function ensureProjectDebugScaffolding(rootDir) {
+    const files = [
+        [path.join(rootDir, REVO_DEBUG_JS_FILE), ''],
+        [path.join(rootDir, REVO_DEBUG_TS_FILE), ''],
+        [path.join(rootDir, REVO_DEBUG_INPUT_FILE), '{}\n'],
+        [path.join(rootDir, REVO_DEBUG_CONFIG_FILE), `${JSON.stringify({
+                timeout: 10,
+                memory: 128,
+                production: false,
+            }, null, 2)}\n`],
+        [path.join(rootDir, REVO_PLAYGROUND_JS_FILE), ''],
+        [path.join(rootDir, REVO_PLAYGROUND_TS_FILE), ''],
+    ];
+    for (const [filePath, contents] of files) {
+        if (fs.existsSync(filePath)) {
+            continue;
+        }
+        fs.writeFileSync(filePath, contents);
+    }
+}
+export function ensureProjectConfig(rootDir) {
+    const tsconfigPath = path.join(rootDir, 'tsconfig.json');
+    const jsconfigPath = path.join(rootDir, 'jsconfig.json');
+    if (!fs.existsSync(tsconfigPath) && !fs.existsSync(jsconfigPath)) {
+        writeJsonFile(tsconfigPath, {
+            compilerOptions: {
+                allowJs: true,
+                checkJs: false,
+                noEmit: true,
+                skipLibCheck: true,
+            },
+            include: DEFAULT_PROJECT_INCLUDE,
+            exclude: DEFAULT_PROJECT_EXCLUDE,
+        });
+        return {
+            filePath: tsconfigPath,
+            action: 'created',
+        };
+    }
+    const filePath = fs.existsSync(tsconfigPath) ? tsconfigPath : jsconfigPath;
+    const parsed = parseConfigFile(filePath);
+    const compilerOptions = ensureObjectField(parsed, 'compilerOptions', filePath);
+    if (compilerOptions.allowJs === undefined) {
+        compilerOptions.allowJs = true;
+    }
+    if (compilerOptions.noEmit === undefined) {
+        compilerOptions.noEmit = true;
+    }
+    if (compilerOptions.skipLibCheck === undefined) {
+        compilerOptions.skipLibCheck = true;
+    }
+    const files = ensureStringArray(parsed.files, 'files', filePath);
+    const include = ensureStringArray(parsed.include, 'include', filePath);
+    if (files) {
+        parsed.files = appendUnique(files, REVO_TYPES_FILE);
+    }
+    else if (include) {
+        parsed.include = appendUnique(include, REVO_TYPES_FILE);
+    }
+    else {
+        parsed.include = DEFAULT_PROJECT_INCLUDE;
+    }
+    writeJsonFile(filePath, parsed);
+    return {
+        filePath,
+        action: 'patched',
+    };
+}
+export function ensureProjectGitignore(rootDir) {
+    const filePath = path.join(rootDir, '.gitignore');
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, `${REVO_TYPES_GITIGNORE_ENTRY}\n`);
+        return {
+            filePath,
+            action: 'created',
+        };
+    }
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const lines = raw.split(/\r?\n/);
+    if (lines.some((line) => line.trim() === REVO_TYPES_GITIGNORE_ENTRY)) {
+        return {
+            filePath,
+            action: 'unchanged',
+        };
+    }
+    const trimmed = raw.replace(/\s*$/, '');
+    const next = trimmed ? `${trimmed}\n${REVO_TYPES_GITIGNORE_ENTRY}\n` : `${REVO_TYPES_GITIGNORE_ENTRY}\n`;
+    fs.writeFileSync(filePath, next);
+    return {
+        filePath,
+        action: 'patched',
+    };
+}

package/dist/src/prompt.d.ts

@@ -0,0 +1,4 @@
+export declare function isInteractiveTerminal(): boolean;
+export declare function promptText(message: string, defaultValue?: string): Promise<string>;
+export declare function promptSecret(message: string): Promise<string>;
+export declare function promptConfirm(message: string, defaultValue?: boolean): Promise<boolean>;