@revoengine/cli 1.0.4 → 1.0.5

package/README.md

@@ -57,7 +57,7 @@ revo project init ./app
 revo project update ./app
 ```
 
-This writes or refreshes `.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. Pass a path such as `./backend` when the RevoEngine workspace is nested.
+This writes or refreshes root `.revoengine/types/revo.editor.d.ts`, `.revoengine/types/revo.editor.definitions.json`, and `.revoengine/revo.json`, patches the workspace `tsconfig.json` or `jsconfig.json`, and updates root `.gitignore` so the generated editor bundle stays local by default. Pass a path such as `./backend` when the RevoEngine workspace is nested; the path is saved as `.revoengine/revo.json.workspace` while root `.revoengine/` remains the single state directory.
 
 ## Common commands
 
@@ -117,6 +117,7 @@ Debug one local component in sandbox:
 revo component debug 6dfb536a-1111-4222-8333-123456789abc
 revo component debug 6dfb536a-1111-4222-8333-123456789abc -d '{"filters":{}}'
 revo component debug 6dfb536a-1111-4222-8333-123456789abc --timeout 30 --memory 256
+revo component debug 6dfb536a-1111-4222-8333-123456789abc --stream
 ```
 
 Pulled components are stored as a tree:
@@ -145,6 +146,9 @@ Bulk sync behavior:
 - 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.
+- `revo component debug --stream` posts to `debug/stream`, writes live `api.log()` frames to stderr, and writes the final raw result payload to stdout.
+- Debug responses are saved under `.revoengine/output/debug_<timestamp>.json`.
+- Debug includes local `CODE_TS_LIB` and `CODE_JS_LIB` components as temporary `extraLibs` overrides by default. Use `--no-extra-libs` when you want backend-saved libraries only.
 - 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/client.d.ts

@@ -9,6 +9,10 @@ export type ComponentListRequest = {
     path?: string;
     query?: Record<string, unknown>;
 };
+export type DebugStreamEvent = {
+    event: string;
+    data: unknown;
+};
 export type ClientOptions = {
     baseUrl?: string;
     instance?: string;
@@ -64,6 +68,7 @@ export declare class RevoClient {
     listEndpoints(): Promise<unknown>;
     getEditorTypes(requestPath?: string): Promise<unknown>;
     debugComponent(requestPath: string, body: unknown): Promise<unknown>;
+    debugComponentStream(requestPath: string, body: unknown): AsyncGenerator<DebugStreamEvent>;
     search(params: Record<string, unknown>): Promise<unknown>;
     listComponents(options?: ComponentListRequest): Promise<unknown>;
     getComponent(componentId: string): Promise<unknown>;

package/dist/src/client.js

@@ -125,6 +125,73 @@ async function readResponseData(response) {
     }
     return text;
 }
+function parseSseFrame(frame) {
+    let event = 'message';
+    const dataLines = [];
+    for (const line of frame.split(/\r?\n/g)) {
+        if (!line || line.startsWith(':')) {
+            continue;
+        }
+        const separatorIndex = line.indexOf(':');
+        const field = separatorIndex >= 0 ? line.slice(0, separatorIndex) : line;
+        const rawValue = separatorIndex >= 0 ? line.slice(separatorIndex + 1) : '';
+        const value = rawValue.startsWith(' ') ? rawValue.slice(1) : rawValue;
+        if (field === 'event') {
+            event = value || event;
+        }
+        else if (field === 'data') {
+            dataLines.push(value);
+        }
+    }
+    if (dataLines.length === 0) {
+        return null;
+    }
+    const rawData = dataLines.join('\n');
+    let data = rawData;
+    try {
+        data = JSON.parse(rawData);
+    }
+    catch {
+        // Keep non-JSON SSE payloads readable instead of dropping them.
+    }
+    return {
+        event,
+        data,
+    };
+}
+async function* readSseEvents(response) {
+    if (!response.body) {
+        return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let separatorMatch = buffer.match(/\r?\n\r?\n/);
+        while (separatorMatch?.index !== undefined) {
+            const frame = buffer.slice(0, separatorMatch.index);
+            buffer = buffer.slice(separatorMatch.index + separatorMatch[0].length);
+            const event = parseSseFrame(frame);
+            if (event) {
+                yield event;
+            }
+            separatorMatch = buffer.match(/\r?\n\r?\n/);
+        }
+    }
+    buffer += decoder.decode();
+    const trailing = buffer.trim();
+    if (trailing) {
+        const event = parseSseFrame(trailing);
+        if (event) {
+            yield event;
+        }
+    }
+}
 function readProfileInstanceId(profile) {
     if (!profile || typeof profile !== 'object' || Array.isArray(profile)) {
         return '';
@@ -316,6 +383,43 @@ export class RevoClient {
             spinnerLabel: 'Debugging component',
         });
     }
+    async *debugComponentStream(requestPath, body) {
+        this.assertReady();
+        await this.validateSession();
+        const url = buildUrl(this.baseUrl, requestPath);
+        const headers = new Headers();
+        headers.set('Accept', 'text/event-stream');
+        headers.set('Content-Type', 'application/json');
+        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);
+        }
+        const response = await this.fetchImpl(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const data = await readResponseData(response);
+            if (response.status === 401) {
+                saveAuthValidationState({
+                    key: this.authValidationKey,
+                    status: 'not_authenticated',
+                    checkedAt: Date.now(),
+                });
+                throw new AuthenticationError(401, 'Not authenticated. Run `revo auth login`.', data);
+            }
+            if (response.status === 403) {
+                throw new PermissionDeniedError(requestPath, `Access denied for ${requestPath}.`, data);
+            }
+            throw new ApiError(response.status, toErrorMessage(typeof data === 'string' ? data : JSON.stringify(data), response.status), data);
+        }
+        for await (const event of readSseEvents(response)) {
+            yield event;
+        }
+    }
     async search(params) {
         return this.requestData('GET', '/api/v1/search', { query: params });
     }

package/dist/src/commands/component.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { ApiError, PermissionDeniedError } from "../client.js";
-import { buildSandboxDebugUrl, extractSandboxEndpoint, resolveProjectWorkspace } from "../project.js";
+import { buildSandboxDebugStreamUrl, 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__';
@@ -794,7 +794,7 @@ function buildDebugElements(component) {
     if (!componentName) {
         throw new Error('Missing component name in local manifest.');
     }
-    return (component.elements || []).map((element) => {
+    return [...(component.elements || [])].sort((left, right) => left.order - right.order).map((element) => {
         const details = element.details || '';
         return {
             key: element.key,
@@ -809,6 +809,101 @@ function buildDebugElements(component) {
         };
     });
 }
+function isDebugLibraryType(type) {
+    return type === 'CODE_TS_LIB' || type === 'CODE_JS_LIB';
+}
+function readLibraryDebugCode(cwd, type) {
+    const fileName = type === 'CODE_TS_LIB' ? 'debug_code.ts' : 'debug_code.js';
+    const filePath = path.join(cwd, '.revoengine', fileName);
+    return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+}
+function buildDebugPayload(cwd, component, input) {
+    const type = normalizeComponentType(component);
+    const base = {
+        type,
+        inputs: input.inputs,
+        timeout: input.timeout,
+        memory: input.memory,
+        ...(input.extraLibs?.length ? { extraLibs: input.extraLibs } : {}),
+    };
+    if (!isDebugLibraryType(type)) {
+        return {
+            ...base,
+            elements: buildDebugElements(component),
+        };
+    }
+    return {
+        ...base,
+        libName: component.name || '',
+        libElements: buildDebugElements(component),
+        elements: [
+            {
+                key: 'Code',
+                order: 0,
+                details: readLibraryDebugCode(cwd, type),
+                hidden: false,
+            },
+        ],
+    };
+}
+function collectDebugExtraLibs(cwd, currentComponentId) {
+    return getComponentManifestPaths(getWorkspaceRoot(cwd))
+        .map((manifestPath) => readWorkspaceComponentSafe(manifestPath))
+        .filter((component) => Boolean(component))
+        .filter((component) => {
+        const type = normalizeComponentType(component);
+        const componentId = component.componentId || component.id || '';
+        return isDebugLibraryType(type) && componentId !== currentComponentId && Boolean(component.name);
+    })
+        .map((component) => ({
+        name: component.name,
+        type: normalizeComponentType(component),
+        elements: buildDebugElements(component),
+    }));
+}
+function formatProcessLog(log) {
+    if (!log || typeof log !== 'object' || Array.isArray(log)) {
+        return String(log ?? '');
+    }
+    const record = log;
+    const parts = [
+        typeof record.time === 'string' ? record.time : '',
+        typeof record.type === 'string' ? record.type : 'INFO',
+        typeof record.context === 'string' && record.context ? `[${record.context}]` : '',
+        typeof record.details?.message === 'string' ? record.details.message : '',
+    ].filter(Boolean);
+    const args = record.details?.args === undefined ? '' : ` ${JSON.stringify(record.details.args)}`;
+    return `${parts.join(' ')}${args}`;
+}
+function writeDebugOutputFile(cwd, response) {
+    if (response === undefined || response === null || response === '') {
+        return '';
+    }
+    const outputDir = path.join(cwd, '.revoengine', 'output');
+    fs.mkdirSync(outputDir, { recursive: true });
+    const timestamp = Math.floor(Date.now() / 1000);
+    let outputFile = path.join(outputDir, `debug_${timestamp}.json`);
+    let suffix = 1;
+    while (fs.existsSync(outputFile)) {
+        outputFile = path.join(outputDir, `debug_${timestamp}_${suffix}.json`);
+        suffix += 1;
+    }
+    fs.writeFileSync(outputFile, `${JSON.stringify(response, null, 2)}\n`);
+    return outputFile;
+}
+function extractResultPayload(response) {
+    if (!response || typeof response !== 'object' || Array.isArray(response)) {
+        return response;
+    }
+    const record = response;
+    if (Object.prototype.hasOwnProperty.call(record, 'result')) {
+        return record.result;
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'results')) {
+        return record.results;
+    }
+    return response;
+}
 async function debugSingleComponent(context, componentId) {
     const manifests = findComponentManifestsById(context.cwd, componentId);
     if (manifests.length === 0) {
@@ -819,23 +914,50 @@ async function debugSingleComponent(context, componentId) {
     }
     const manifestPath = manifests[0];
     const component = readWorkspaceComponent(manifestPath);
-    const type = normalizeComponentType(component);
+    const componentKey = component.componentId || component.id || componentId;
     const inputs = parseDebugInputs(context.args);
     const timeout = parseDebugNumber(context.args, ['timeout', 't'], 10, 600, 'Timeout');
     const memory = parseDebugNumber(context.args, ['memory', 'm'], 128, 1024, 'Memory');
+    const stream = readBoolFlag(context.args, ['stream']);
+    const includeExtraLibs = !readBoolFlag(context.args, ['no-extra-libs']);
     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.');
     }
-    const response = await context.client.debugComponent(buildSandboxDebugUrl(sandboxEndpoint), {
-        elements: buildDebugElements(component),
-        type,
+    const payload = buildDebugPayload(context.cwd, component, {
         inputs,
         timeout,
         memory,
+        extraLibs: includeExtraLibs ? collectDebugExtraLibs(context.cwd, componentKey) : [],
     });
-    context.print(response);
+    if (stream) {
+        let result;
+        let done = false;
+        for await (const event of context.client.debugComponentStream(buildSandboxDebugStreamUrl(sandboxEndpoint), payload)) {
+            if (event.event === 'log') {
+                process.stderr.write(`${formatProcessLog(event.data)}\n`);
+            }
+            else if (event.event === 'result') {
+                result = event.data;
+            }
+            else if (event.event === 'error') {
+                throw new Error(`Debug stream failed: ${JSON.stringify(event.data)}`);
+            }
+            else if (event.event === 'done') {
+                done = true;
+            }
+        }
+        if (!done) {
+            throw new Error('Debug stream ended before the done event.');
+        }
+        writeDebugOutputFile(context.cwd, result);
+        context.print(extractResultPayload(result));
+        return;
+    }
+    const response = await context.client.debugComponent(buildSandboxDebugUrl(sandboxEndpoint), payload);
+    writeDebugOutputFile(context.cwd, response);
+    context.print(extractResultPayload(response));
 }
 export async function handleComponentCommand(context) {
     const { args } = context;
@@ -855,7 +977,7 @@ export async function handleComponentCommand(context) {
     if (subcommand === 'debug') {
         const componentId = args._[2] || readFlag(args, ['id', 'i']) || '';
         if (!componentId) {
-            throw new Error('Missing component ID. Usage: `revo component debug <componentId> [-d <json>] [--timeout <seconds>] [--memory <mb>]`.');
+            throw new Error('Missing component ID. Usage: `revo component debug <componentId> [-d <json>] [--timeout <seconds>] [--memory <mb>] [--stream]`.');
         }
         await debugSingleComponent(context, componentId);
         return;

package/dist/src/commands/project.js

@@ -1,10 +1,14 @@
 import path from 'node:path';
 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)}`);
-    println(`Wrote ${path.relative(targetDir, result.metadataFile)}`);
-    println(`${result.configResult.action === 'created' ? 'Created' : 'Patched'} ${path.basename(result.configResult.filePath)}`);
+function printSyncSummary(println, projectRoot, workspaceRoot, result, prefix) {
+    const workspaceDirectory = path.relative(projectRoot, workspaceRoot) || '.';
+    println(`${prefix} ${projectRoot}`);
+    if (workspaceDirectory !== '.') {
+        println(`Workspace ${workspaceDirectory}`);
+    }
+    println(`Wrote ${path.relative(projectRoot, result.typesFile)}`);
+    println(`Wrote ${path.relative(projectRoot, result.metadataFile)}`);
+    println(`${result.configResult.action === 'created' ? 'Created' : 'Patched'} ${path.relative(projectRoot, result.configResult.filePath)}`);
     if (result.gitignoreResult.action === 'created') {
         println('Created .gitignore');
     }
@@ -33,8 +37,8 @@ export async function handleProjectCommand(context) {
     if (invocation.extraArgs.length > 0) {
         throw new Error(`Project ${invocation.action} accepts at most one path argument.`);
     }
-    const targetDir = resolveProjectTarget(cwd, invocation.targetArg);
+    const layout = resolveProjectTarget(cwd, invocation.targetArg);
     const syncInput = await resolveProjectSyncInput(context);
-    const result = syncProjectFiles(targetDir, syncInput);
-    printSyncSummary(println, targetDir, result, invocation.action === 'update' ? 'Updated Revo project in' : 'Initialized Revo project in');
+    const result = syncProjectFiles(layout, syncInput);
+    printSyncSummary(println, layout.projectRoot, layout.workspaceRoot, result, invocation.action === 'update' ? 'Updated Revo project in' : 'Initialized Revo project in');
 }

package/dist/src/project.d.ts

@@ -2,6 +2,7 @@ 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_TYPES_DEFINITIONS_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;
@@ -17,6 +18,7 @@ export type ProjectInvocation = {
 };
 export type EditorTypesBundle = {
     code: string;
+    definitions?: unknown[];
     endpoint?: string;
     apiVersion?: string;
     libVersion?: string;
@@ -36,6 +38,7 @@ export type RevoProjectMetadata = {
 export type ProjectSyncInput = {
     endpoint: string;
     code: string;
+    definitions: unknown[];
     apiVersion: string;
     libVersion: string;
     hash: string;
@@ -49,12 +52,18 @@ export type GitignorePatchResult = {
     filePath: string;
     action: 'created' | 'patched' | 'unchanged';
 };
+export type ProjectTargetLayout = {
+    projectRoot: string;
+    workspaceRoot: string;
+    workspaceDirectory: string;
+};
 export declare function resolveProjectInvocation(args: ParsedArgs): ProjectInvocation;
-export declare function resolveProjectTarget(cwd: string, targetArg?: string): string;
+export declare function resolveProjectTarget(cwd: string, targetArg?: string): ProjectTargetLayout;
 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 buildSandboxDebugStreamUrl(endpoint: string): string;
 export declare function extractSandboxEndpoint(profile: unknown): string | null;
 export declare function buildProjectMetadata(input: {
     baseUrl: string;
@@ -80,18 +89,20 @@ export declare function buildProjectSyncState(input: {
 }): {
     endpoint: string;
     code: string;
+    definitions: unknown[];
     apiVersion: string;
     libVersion: string;
     hash: string;
     lastSyncAt: string;
 };
-export declare function syncProjectFiles(targetDir: string, input: ProjectSyncInput): {
+export declare function syncProjectFiles(layoutOrTargetDir: ProjectTargetLayout | string, input: ProjectSyncInput): {
     projectDir: string;
     typesFile: string;
+    definitionsFile: string;
     metadataFile: string;
     configResult: ProjectConfigResult;
     gitignoreResult: GitignorePatchResult;
 };
 export declare function ensureProjectDebugScaffolding(rootDir: string): void;
-export declare function ensureProjectConfig(rootDir: string): ProjectConfigResult;
+export declare function ensureProjectConfig(rootDir: string, typesInclude?: string): ProjectConfigResult;
 export declare function ensureProjectGitignore(rootDir: string): GitignorePatchResult;

package/dist/src/project.js

@@ -4,6 +4,7 @@ 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_TYPES_DEFINITIONS_FILE = path.join(REVO_TYPES_DIR, 'revo.editor.definitions.json');
 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');
@@ -208,8 +209,29 @@ export function resolveProjectInvocation(args) {
         extraArgs: second ? [second, ...rest] : rest,
     };
 }
+function normalizeWorkspaceDirectory(projectRoot, workspaceRoot) {
+    const relative = path.relative(projectRoot, workspaceRoot).split(path.sep).join('/');
+    if (relative === '') {
+        return '.';
+    }
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error('Project workspace directory must stay inside the Revo project root.');
+    }
+    return relative;
+}
 export function resolveProjectTarget(cwd, targetArg) {
-    return path.resolve(cwd, targetArg || '.');
+    const existingProjectRoot = resolveProjectRoot(cwd);
+    const projectRoot = existingProjectRoot || path.resolve(cwd);
+    const existingMetadata = existingProjectRoot ? readProjectMetadata(projectRoot) : null;
+    const workspaceRoot = targetArg
+        ? path.resolve(cwd, targetArg)
+        : resolveProjectWorkspaceRoot(projectRoot, existingMetadata?.workspace || '.');
+    const workspaceDirectory = normalizeWorkspaceDirectory(projectRoot, workspaceRoot);
+    return {
+        projectRoot,
+        workspaceRoot,
+        workspaceDirectory,
+    };
 }
 export function extractEditorTypesBundle(payload) {
     const root = isRecord(payload) && isRecord(payload.data) ? payload.data : payload;
@@ -223,6 +245,7 @@ export function extractEditorTypesBundle(payload) {
     }
     return {
         code,
+        definitions: Array.isArray(root.definitions) ? root.definitions : [],
         endpoint: readString(root.endpoint) || readString(meta?.endpoint),
         apiVersion: readString(root.apiVersion) || readString(meta?.apiVersion),
         libVersion: readString(root.libVersion) || readString(meta?.libVersion),
@@ -256,6 +279,15 @@ export function buildSandboxDebugUrl(endpoint) {
     url.hash = '';
     return url.toString();
 }
+export function buildSandboxDebugStreamUrl(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/stream`.replace(/\/{2,}/g, '/');
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+}
 export function extractSandboxEndpoint(profile) {
     if (!profile || typeof profile !== 'object') {
         return null;
@@ -368,20 +400,38 @@ export function buildProjectSyncState(input) {
     return {
         endpoint: metadata.endpoint,
         code: input.bundle.code,
+        definitions: input.bundle.definitions ?? [],
         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);
+function toPosixRelative(fromDir, toPath) {
+    const relative = path.relative(fromDir, toPath).split(path.sep).join('/');
+    return relative || path.basename(toPath);
+}
+export function syncProjectFiles(layoutOrTargetDir, input) {
+    const layout = typeof layoutOrTargetDir === 'string'
+        ? {
+            projectRoot: layoutOrTargetDir,
+            workspaceRoot: layoutOrTargetDir,
+            workspaceDirectory: '.',
+        }
+        : layoutOrTargetDir;
+    const { projectRoot, workspaceRoot, workspaceDirectory } = layout;
+    const projectDir = path.join(projectRoot, REVO_PROJECT_DIR);
+    const typesDir = path.join(projectRoot, 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);
+    const typesFile = path.join(projectRoot, REVO_TYPES_FILE);
+    const definitionsFile = path.join(projectRoot, REVO_TYPES_DEFINITIONS_FILE);
+    const metadataFile = path.join(projectRoot, REVO_METADATA_FILE);
     fs.writeFileSync(typesFile, input.code);
+    writeJsonFile(definitionsFile, {
+        schemaVersion: 1,
+        definitions: input.definitions,
+    });
     writeJsonFile(metadataFile, {
         schemaVersion: 1,
         endpoint: input.endpoint,
@@ -390,13 +440,15 @@ export function syncProjectFiles(targetDir, input) {
         libVersion: input.libVersion,
         hash: input.hash,
         lastSyncAt: input.lastSyncAt,
+        ...(workspaceDirectory !== '.' ? { workspace: workspaceDirectory } : {}),
     });
-    const configResult = ensureProjectConfig(targetDir);
-    const gitignoreResult = ensureProjectGitignore(targetDir);
-    ensureProjectDebugScaffolding(targetDir);
+    const configResult = ensureProjectConfig(workspaceRoot, toPosixRelative(workspaceRoot, typesFile));
+    const gitignoreResult = ensureProjectGitignore(projectRoot);
+    ensureProjectDebugScaffolding(projectRoot);
     return {
         projectDir,
         typesFile,
+        definitionsFile,
         metadataFile,
         configResult,
         gitignoreResult,
@@ -422,7 +474,7 @@ export function ensureProjectDebugScaffolding(rootDir) {
         fs.writeFileSync(filePath, contents);
     }
 }
-export function ensureProjectConfig(rootDir) {
+export function ensureProjectConfig(rootDir, typesInclude = REVO_TYPES_FILE) {
     const tsconfigPath = path.join(rootDir, 'tsconfig.json');
     const jsconfigPath = path.join(rootDir, 'jsconfig.json');
     if (!fs.existsSync(tsconfigPath) && !fs.existsSync(jsconfigPath)) {
@@ -433,7 +485,10 @@ export function ensureProjectConfig(rootDir) {
                 noEmit: true,
                 skipLibCheck: true,
             },
-            include: DEFAULT_PROJECT_INCLUDE,
+            include: [
+                ...DEFAULT_PROJECT_INCLUDE.filter((entry) => entry !== REVO_TYPES_FILE),
+                typesInclude,
+            ],
             exclude: DEFAULT_PROJECT_EXCLUDE,
         });
         return {
@@ -456,13 +511,16 @@ export function ensureProjectConfig(rootDir) {
     const files = ensureStringArray(parsed.files, 'files', filePath);
     const include = ensureStringArray(parsed.include, 'include', filePath);
     if (files) {
-        parsed.files = appendUnique(files, REVO_TYPES_FILE);
+        parsed.files = appendUnique(files, typesInclude);
     }
     else if (include) {
-        parsed.include = appendUnique(include, REVO_TYPES_FILE);
+        parsed.include = appendUnique(include, typesInclude);
     }
     else {
-        parsed.include = DEFAULT_PROJECT_INCLUDE;
+        parsed.include = [
+            ...DEFAULT_PROJECT_INCLUDE.filter((entry) => entry !== REVO_TYPES_FILE),
+            typesInclude,
+        ];
     }
     writeJsonFile(filePath, parsed);
     return {

package/dist/src/ui.js

@@ -112,7 +112,7 @@ function renderCommandCatalog() {
         commandRow('revo component pull --all [--force] [--stale]', 'Pull every available component with confirmation'),
         commandRow('revo component push <componentId...>', 'Push one or more local components'),
         commandRow('revo component push --all [--force]', 'Push every local component.json with confirmation'),
-        commandRow('revo component debug <componentId> [BODY]', 'Debug one local component against sandbox'),
+        commandRow('revo component debug <componentId> [BODY] [--stream]', 'Debug one local component against sandbox'),
         '',
         paintHeader('Low-Level'),
         commandRow('revo search <CODE|SIMPLE> <term>', 'Search code references or all platform content'),

package/package.json

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