@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/resource-syncs/util.d.ts

@@ -0,0 +1,19 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function unwrapData<T>(value: unknown): T;
+export declare function requireProjectLayout(cwd: string, resourceLabel: string): {
+    projectRoot: string;
+    workspaceRoot: string;
+};
+export declare function stableKeySuffix(stableKey: string): string;
+export declare function findManifestFiles(directory: string, manifestFileName: string): string[];
+export declare function writeManifestIfChanged(filePath: string, manifest: unknown): boolean;
+export declare function writePulledManifest(input: {
+    filePath: string;
+    manifest: unknown;
+    previousPath?: string;
+    root: string;
+    force?: boolean;
+}): void;
+export declare function removeRelocatedManifest(filePath: string, root: string): void;
+export declare function localTargetPath(cwd: string, manifestPath: string): string;
+export declare function toPortableRelativePath(root: string, filePath: string): string;

package/dist/src/resource-syncs/util.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { hashStable } from "../component-lock.js";
+import { resolveProjectRoot, resolveProjectWorkspace } from "../project.js";
+import { sanitizeSegment, writeJsonFile } from "../utils.js";
+import { replaceWorkspaceResourceDirectory } from "../workspace-resource.js";
+export function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function unwrapData(value) {
+    return isRecord(value) && isRecord(value.data) ? value.data : value;
+}
+export function requireProjectLayout(cwd, resourceLabel) {
+    const projectRoot = resolveProjectRoot(cwd);
+    const workspaceRoot = resolveProjectWorkspace(cwd);
+    if (!projectRoot || !workspaceRoot) {
+        throw new Error(`${resourceLabel} sync requires a configured Revo project. Run \`revo project init [path]\` first.`);
+    }
+    return { projectRoot, workspaceRoot };
+}
+export function stableKeySuffix(stableKey) {
+    const suffix = stableKey.includes('#') ? stableKey.slice(stableKey.lastIndexOf('#') + 1) : '';
+    return sanitizeSegment(suffix || hashStable(stableKey).slice(0, 8));
+}
+export function findManifestFiles(directory, manifestFileName) {
+    if (!fs.existsSync(directory))
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...findManifestFiles(entryPath, manifestFileName));
+        else if (entry.isFile() && entry.name === manifestFileName)
+            files.push(entryPath);
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+export function writeManifestIfChanged(filePath, manifest) {
+    const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === serialized)
+        return false;
+    writeJsonFile(filePath, manifest);
+    return true;
+}
+// Nested manifests belong to separate resources (notably DB partitions).
+// Preserve those directories until their own pull or explicit prune handles them.
+function copyNestedResourceDirectories(source, target, manifestName) {
+    if (!fs.existsSync(source)) {
+        return;
+    }
+    for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const sourceDirectory = path.join(source, entry.name);
+        const targetDirectory = path.join(target, entry.name);
+        if (fs.existsSync(path.join(sourceDirectory, manifestName))) {
+            fs.cpSync(sourceDirectory, targetDirectory, { recursive: true, dereference: false });
+        }
+        else {
+            copyNestedResourceDirectories(sourceDirectory, targetDirectory, manifestName);
+        }
+    }
+}
+export function writePulledManifest(input) {
+    const directory = path.dirname(input.filePath);
+    const manifestName = path.basename(input.filePath);
+    if (input.force) {
+        const serialized = `${JSON.stringify(input.manifest, null, 2)}\n`;
+        replaceWorkspaceResourceDirectory(input.root, directory, (staged) => {
+            copyNestedResourceDirectories(directory, staged, manifestName);
+            fs.writeFileSync(path.join(staged, manifestName), serialized);
+        });
+    }
+    else {
+        writeManifestIfChanged(input.filePath, input.manifest);
+    }
+    if (!input.previousPath || input.previousPath === input.filePath || !fs.existsSync(input.previousPath)) {
+        return;
+    }
+    const previousDirectory = path.dirname(input.previousPath);
+    const previousStat = fs.statSync(previousDirectory);
+    const currentStat = fs.statSync(directory);
+    if (previousStat.dev === currentStat.dev && previousStat.ino === currentStat.ino) {
+        return;
+    }
+    if (input.force) {
+        replaceWorkspaceResourceDirectory(input.root, previousDirectory, (staged) => {
+            copyNestedResourceDirectories(previousDirectory, staged, manifestName);
+        });
+        removeEmptyResourceParents(previousDirectory, input.root);
+    }
+    else {
+        removeRelocatedManifest(input.previousPath, input.root);
+    }
+}
+function removeEmptyResourceParents(directory, root) {
+    const resolvedRoot = path.resolve(root);
+    let current = path.resolve(directory);
+    while (current.startsWith(`${resolvedRoot}${path.sep}`) && fs.readdirSync(current).length === 0) {
+        fs.rmdirSync(current);
+        current = path.dirname(current);
+    }
+}
+export function removeRelocatedManifest(filePath, root) {
+    if (!fs.existsSync(filePath))
+        return;
+    fs.unlinkSync(filePath);
+    removeEmptyResourceParents(path.dirname(filePath), root);
+}
+export function localTargetPath(cwd, manifestPath) {
+    return path.relative(cwd, path.dirname(manifestPath)) || '.';
+}
+export function toPortableRelativePath(root, filePath) {
+    return path.relative(root, filePath).split(path.sep).join('/');
+}

package/dist/src/runtime-view.d.ts

@@ -10,6 +10,7 @@ export type RuntimeViewModel = {
     nodeVersion: string;
     configDir: string;
     runtime: ReturnType<typeof resolveRuntimeConfig>;
+    environmentName: string;
     auth: AuthViewState;
 };
 export declare function buildRuntimeViewModel(context: CommandContext, options?: {

package/dist/src/runtime-view.js

@@ -1,7 +1,8 @@
-import { getConfigDir, resolveRuntimeConfig } from "./config.js";
+import { getActiveEnvironmentName, getConfigDir, resolveRuntimeConfig } from "./config.js";
 import { AuthenticationError } from "./client.js";
 function resolveArgsRuntime(context) {
     return resolveRuntimeConfig({
+        envName: typeof context.args.env === 'string' ? context.args.env : undefined,
         baseUrl: typeof context.args.url === 'string'
             ? context.args.url
             : typeof context.args.baseUrl === 'string'
@@ -44,6 +45,9 @@ function extractEmail(profile) {
 }
 export async function buildRuntimeViewModel(context, options = {}) {
     const runtime = resolveArgsRuntime(context);
+    const environmentName = typeof context.args.env === 'string'
+        ? context.args.env
+        : getActiveEnvironmentName();
     const auth = {
         status: 'not_authenticated',
         validation: null,
@@ -75,6 +79,7 @@ export async function buildRuntimeViewModel(context, options = {}) {
         nodeVersion: process.version,
         configDir: getConfigDir(),
         runtime,
+        environmentName,
         auth,
     };
 }

package/dist/src/sync-output.d.ts

@@ -0,0 +1,38 @@
+import type { CommandContext } from './types.ts';
+export type WorkspaceSyncStatus = 'pulled' | 'pruned' | 'deployed' | 'skipped' | 'failed' | 'write-unverified';
+export type WorkspaceSyncResult = {
+    status: WorkspaceSyncStatus;
+    targetPath: string;
+    reason?: string;
+};
+export type SyncOutputStatus = 'Pulled' | 'Pruned' | 'Skipped' | 'Deployed' | 'Activated' | 'Deactivated' | 'Failed' | 'Unverified';
+export type SyncPlanDetail = {
+    label: string;
+    values: string | ReadonlyArray<string>;
+};
+export type SyncPlanItem = {
+    status: string;
+    stableKey?: string;
+    name?: string;
+    target?: string;
+    reason?: string;
+    changedFields?: ReadonlyArray<string>;
+    details?: ReadonlyArray<SyncPlanDetail>;
+};
+export type SyncPlanOutput = {
+    title: string;
+    environment: string;
+    counts: Readonly<Record<string, number>>;
+    items: ReadonlyArray<SyncPlanItem>;
+    warnings?: ReadonlyArray<string>;
+    blockers?: ReadonlyArray<string>;
+};
+export declare function printSyncPlan(println: CommandContext['println'], input: SyncPlanOutput): void;
+export declare function printSyncStatus(println: CommandContext['println'], input: {
+    status: SyncOutputStatus;
+    direction: 'pull' | 'push';
+    targetPath: string;
+    reason?: string;
+}): void;
+export declare function printSyncNotice(println: CommandContext['println'], message: string): void;
+export declare function printSyncSummary(println: CommandContext['println'], label: 'Pulled' | 'Deployed' | 'Activated', results: ReadonlyArray<Pick<WorkspaceSyncResult, 'status'>>, durationMs: number): void;

package/dist/src/sync-output.js

@@ -0,0 +1,131 @@
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    red: '\u001b[31m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    cyan: '\u001b[36m',
+    blue: '\u001b[34m',
+    magenta: '\u001b[35m',
+};
+function supportsColor() {
+    return Boolean(process.stdout.isTTY || process.env.FORCE_COLOR);
+}
+function paint(text, code) {
+    return supportsColor() ? `${code}${text}${ANSI.reset}` : text;
+}
+function paintStatus(status) {
+    if (status === 'Skipped' || status === 'Pruned') {
+        return paint(status.padEnd(9), ANSI.bold + ANSI.yellow);
+    }
+    if (status === 'Failed') {
+        return paint(status.padEnd(9), ANSI.bold + ANSI.red);
+    }
+    if (status === 'Unverified') {
+        return paint(status.padEnd(9), ANSI.bold + ANSI.magenta);
+    }
+    if (status === 'Notice') {
+        return paint(status.padEnd(9), ANSI.bold + ANSI.magenta);
+    }
+    return paint(status.padEnd(9), ANSI.bold + ANSI.green);
+}
+function formatDuration(durationMs) {
+    if (durationMs < 1_000) {
+        return `${durationMs}ms`;
+    }
+    const seconds = durationMs / 1_000;
+    return seconds < 10 ? `${seconds.toFixed(1)}s` : `${Math.round(seconds)}s`;
+}
+const PLAN_STATUS_MARKS = {
+    clean: { symbol: '=', code: ANSI.green },
+    create: { symbol: '+', code: ANSI.bold + ANSI.green },
+    restore: { symbol: '+', code: ANSI.bold + ANSI.yellow },
+    'restore-blocked': { symbol: '!', code: ANSI.bold + ANSI.red },
+    'manual-create': { symbol: '+', code: ANSI.bold + ANSI.yellow },
+    'manual-owner': { symbol: '-', code: ANSI.bold + ANSI.yellow },
+    'local-changed': { symbol: '~', code: ANSI.bold + ANSI.yellow },
+    'safe-update': { symbol: '~', code: ANSI.bold + ANSI.yellow },
+    'remote-changed': { symbol: '>', code: ANSI.bold + ANSI.magenta },
+    conflict: { symbol: '!', code: ANSI.bold + ANSI.red },
+    'missing-lock': { symbol: '?', code: ANSI.bold + ANSI.red },
+    reconciled: { symbol: '=', code: ANSI.bold + ANSI.cyan },
+    'manual-schema-migration-required': { symbol: '!', code: ANSI.bold + ANSI.red },
+    'access-policy-required': { symbol: '!', code: ANSI.bold + ANSI.yellow },
+    'activation-drift': { symbol: '^', code: ANSI.bold + ANSI.yellow },
+    orphan: { symbol: 'o', code: ANSI.dim + ANSI.cyan },
+    'orphan-root': { symbol: 'o', code: ANSI.dim + ANSI.cyan },
+    'orphan-partition': { symbol: 'o', code: ANSI.dim + ANSI.cyan },
+    unmanaged: { symbol: '-', code: ANSI.dim + ANSI.yellow },
+    collision: { symbol: '!', code: ANSI.bold + ANSI.red },
+    skipped: { symbol: '-', code: ANSI.dim + ANSI.yellow },
+    delete: { symbol: '-', code: ANSI.bold + ANSI.red },
+    'delete-partition': { symbol: '-', code: ANSI.bold + ANSI.red },
+    'previously-deleted-partition': { symbol: '!', code: ANSI.bold + ANSI.red },
+    'replacement-requires-two-phases': { symbol: '!', code: ANSI.bold + ANSI.yellow },
+};
+function planDetailValue(values) {
+    return typeof values === 'string' ? values : values.join(', ');
+}
+function printPlanSection(println, label, messages) {
+    if (messages.length === 0) {
+        return;
+    }
+    println('');
+    const code = label === 'Blockers' ? ANSI.bold + ANSI.red : ANSI.bold + ANSI.yellow;
+    println(paint(`${label} (${messages.length})`, code));
+    for (const message of messages)
+        println(`  ${paint('!', code)} ${message}`);
+}
+export function printSyncPlan(println, input) {
+    println(`${paint(`${input.title} plan`, ANSI.bold)} for ${paint(input.environment, ANSI.bold + ANSI.cyan)}`);
+    for (const item of input.items) {
+        const mark = PLAN_STATUS_MARKS[item.status] || { symbol: '-', code: ANSI.dim };
+        const target = item.target || item.stableKey || item.name || 'unknown';
+        println(`${paint(mark.symbol, mark.code)} ${paint(item.status.padEnd(14), mark.code)} ${paint(target, ANSI.cyan)}`);
+        const details = [
+            ...(item.reason ? [{ label: 'reason', values: item.reason }] : []),
+            ...(item.changedFields?.length ? [{ label: 'fields', values: item.changedFields }] : []),
+            ...(item.details || []),
+        ];
+        for (const detail of details) {
+            const value = planDetailValue(detail.values);
+            if (value) {
+                println(`    ${paint(detail.label.padEnd(14), ANSI.dim)} ${value}`);
+            }
+        }
+    }
+    const summary = Object.entries(input.counts)
+        .filter(([, count]) => count > 0)
+        .map(([status, count]) => `${count} ${status}`);
+    println(`${paint('Summary', ANSI.bold)}  ${summary.length > 0 ? summary.join(', ') : 'no resources'}`);
+    printPlanSection(println, 'Warnings', input.warnings || []);
+    printPlanSection(println, 'Blockers', input.blockers || []);
+}
+export function printSyncStatus(println, input) {
+    const engine = paint('RevoEngine', ANSI.bold + ANSI.blue);
+    const arrow = paint(input.direction === 'pull' ? '->' : '<-', ANSI.bold + ANSI.magenta);
+    const targetPath = paint(input.targetPath, ANSI.cyan);
+    const reason = input.reason ? ` ${paint(`(${input.reason})`, ANSI.dim + ANSI.yellow)}` : '';
+    println(`${paintStatus(input.status)} ${engine} ${arrow} ${targetPath}${reason}`);
+}
+export function printSyncNotice(println, message) {
+    println(`${paintStatus('Notice')} ${message}`);
+}
+export function printSyncSummary(println, label, results, durationMs) {
+    const total = results.length;
+    const primaryStatus = label === 'Activated' ? 'deployed' : label.toLowerCase();
+    const primary = results.filter((result) => result.status === primaryStatus).length;
+    const skipped = results.filter((result) => result.status === 'skipped').length;
+    const pruned = results.filter((result) => result.status === 'pruned').length;
+    const failed = results.filter((result) => result.status === 'failed').length;
+    const unverified = results.filter((result) => result.status === 'write-unverified').length;
+    const details = [
+        `${label} ${primary}/${total}`,
+        ...(pruned > 0 ? [`Pruned ${pruned}/${total}`] : []),
+        ...(skipped > 0 ? [`Skipped ${skipped}/${total}`] : []),
+        ...(failed > 0 ? [`Failed ${failed}/${total}`] : []),
+        ...(unverified > 0 ? [`Unverified ${unverified}/${total}`] : []),
+    ];
+    println(`${details.join(', ')} in ${formatDuration(durationMs)}`);
+}

package/dist/src/tracked-resources.d.ts

@@ -0,0 +1,7 @@
+export declare const TRACK_ALL_RESOURCES = "all";
+export declare const TRACKABLE_RESOURCE_TYPES: readonly ["component", "endpoint", "group", "role-group", "job-template", "schedule", "event", "database-schema", "database-view"];
+export type TrackableResourceType = typeof TRACKABLE_RESOURCE_TYPES[number];
+export type TrackedResource = typeof TRACK_ALL_RESOURCES | TrackableResourceType;
+export declare function normalizeTrackedResources(value: string | string[] | null | undefined): TrackedResource[];
+export declare function formatTrackedResources(resources: readonly TrackedResource[]): string;
+export declare function shouldTrackResource(resources: readonly TrackedResource[], resource: TrackableResourceType): boolean;

package/dist/src/tracked-resources.js

@@ -0,0 +1,61 @@
+export const TRACK_ALL_RESOURCES = 'all';
+export const TRACKABLE_RESOURCE_TYPES = ['component', 'endpoint', 'group', 'role-group', 'job-template', 'schedule', 'event', 'database-schema', 'database-view'];
+const RESOURCE_ALIASES = {
+    all: TRACK_ALL_RESOURCES,
+    '*': TRACK_ALL_RESOURCES,
+    component: 'component',
+    components: 'component',
+    endpoint: 'endpoint',
+    endpoints: 'endpoint',
+    group: 'group',
+    groups: 'group',
+    'role-group': 'role-group',
+    'role-groups': 'role-group',
+    rolegroup: 'role-group',
+    rolegroups: 'role-group',
+    'job-template': 'job-template',
+    'job-templates': 'job-template',
+    jobtemplate: 'job-template',
+    jobtemplates: 'job-template',
+    schedule: 'schedule',
+    schedules: 'schedule',
+    event: 'event',
+    events: 'event',
+    'database-schema': 'database-schema',
+    'database-schemas': 'database-schema',
+    database: 'database-schema',
+    databases: 'database-schema',
+    'database-view': 'database-view',
+    'database-views': 'database-view',
+    databaseview: 'database-view',
+    databaseviews: 'database-view',
+};
+export function normalizeTrackedResources(value) {
+    const rawValues = Array.isArray(value) ? value : value ? [value] : [TRACK_ALL_RESOURCES];
+    const normalized = [];
+    for (const rawValue of rawValues) {
+        for (const part of rawValue.split(',')) {
+            const key = part.trim().toLowerCase();
+            if (!key) {
+                continue;
+            }
+            const resource = RESOURCE_ALIASES[key];
+            if (!resource) {
+                throw new Error(`Unsupported tracked resource "${part.trim()}". Supported values: all, component, endpoint, group, role-group, job-template, schedule, event, database-schema, database-view.`);
+            }
+            if (!normalized.includes(resource)) {
+                normalized.push(resource);
+            }
+        }
+    }
+    if (normalized.length === 0 || normalized.includes(TRACK_ALL_RESOURCES)) {
+        return [TRACK_ALL_RESOURCES];
+    }
+    return normalized;
+}
+export function formatTrackedResources(resources) {
+    return resources.join(',');
+}
+export function shouldTrackResource(resources, resource) {
+    return resources.includes(TRACK_ALL_RESOURCES) || resources.includes(resource);
+}

package/dist/src/types.d.ts

@@ -6,11 +6,13 @@ export type ParsedArgs = {
 export type CommandContext = {
     args: ParsedArgs;
     client: RevoClient;
+    componentEnvironment?: string;
     cwd: string;
     packageVersion: string;
     print: (value: unknown) => void;
     println: (message: string) => void;
     error: (message: string) => void;
+    warn?: (message: string) => void;
 };
 export type ComponentElementRecord = {
     componentElementId?: string;
@@ -32,6 +34,231 @@ export type ComponentRecord = {
     active?: boolean;
     async?: boolean;
     version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
     elements?: ComponentElementRecord[];
     [key: string]: unknown;
 };
+export type DatabaseSchemaRecord = {
+    databaseId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    type?: string;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    definition?: unknown[];
+    partition?: Record<string, unknown> | null;
+    parent?: string | {
+        databaseId?: string;
+        id?: string;
+        name?: string;
+    } | null;
+    parentId?: string | null;
+    master?: string | {
+        databaseId?: string;
+        id?: string;
+    } | null;
+    masterId?: string | null;
+    foreignReferences?: unknown[];
+    audit?: unknown;
+    restricted?: boolean;
+    groups?: unknown[];
+    users?: unknown[];
+    tags?: unknown[];
+    deletedAt?: string | null;
+    deletedBy?: string | null;
+    [key: string]: unknown;
+};
+export type DatabaseViewRecord = {
+    databaseViewId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    type?: string;
+    definitionMode?: string;
+    request?: Record<string, unknown> | null;
+    rawQuery?: string | null;
+    definition?: Array<Record<string, unknown>>;
+    sourceDatabaseIds?: string[];
+    sourceFieldDependencies?: Record<string, string[]>;
+    fieldLineage?: unknown[];
+    uniqueKey?: string[] | null;
+    indexes?: unknown[];
+    restricted?: boolean;
+    users?: unknown[];
+    groups?: unknown[];
+    version?: number;
+    internalName?: string;
+    createdAt?: string;
+    createdBy?: string;
+    lastUpdateAt?: string;
+    lastUpdateBy?: string;
+    deletedAt?: string | null;
+    deletedBy?: string | null;
+    [key: string]: unknown;
+};
+export type EndpointOptions = {
+    input?: Record<string, unknown>;
+    guard?: Record<string, unknown>;
+    response?: unknown;
+    httpCode?: number;
+    noResult?: boolean;
+    popResult?: string;
+    customValidateResponse?: unknown;
+    validateResponse?: number;
+    validateHideResponse?: boolean;
+    includeLibs?: string[];
+    excludeLibs?: string[];
+    skipLibs?: boolean;
+    legacyResults?: boolean;
+    hideRequest?: boolean;
+    hideResponse?: boolean;
+    memory?: number;
+    componentSchemaId?: string | null;
+    componentSchemaVersion?: number | null;
+    componentSchemaElement?: string | null;
+    [key: string]: unknown;
+};
+export type EndpointRecord = {
+    endpointId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    timeout?: number;
+    path?: string;
+    method?: string;
+    componentId?: string | null;
+    componentVersion?: number | null;
+    active?: boolean;
+    parts?: number;
+    options?: EndpointOptions | null;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    createdAt?: string;
+    createdBy?: string;
+    lastUpdateAt?: string;
+    lastUpdateBy?: string;
+    deletedAt?: string | null;
+    deletedBy?: string | null;
+    [key: string]: unknown;
+};
+export type RoleGroupRecord = {
+    roleGroupId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    roles?: unknown[];
+    members?: unknown[];
+    users?: unknown[];
+    [key: string]: unknown;
+};
+export type GroupRecord = {
+    groupId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    accessType?: string;
+    ownerId?: string;
+    ownerType?: string;
+    leaderId?: string;
+    avatar?: string | null;
+    memberCount?: number;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    members?: unknown[];
+    users?: unknown[];
+    [key: string]: unknown;
+};
+export type JobTemplateRecord = {
+    jobTemplateId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    componentId?: string;
+    component?: ComponentRecord;
+    componentVersion?: number | null;
+    timeout?: number;
+    triggerUser?: string | null;
+    options?: unknown;
+    inputs?: unknown;
+    active?: boolean;
+    deletedAt?: string | null;
+    [key: string]: unknown;
+};
+export type ScheduleRecord = {
+    scheduleId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    active?: boolean;
+    cron?: string;
+    timezone?: string;
+    targetType?: string;
+    targetId?: string;
+    targetVersion?: number | null;
+    targetConfig?: Record<string, unknown> | null;
+    systemManaged?: boolean;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    deletedAt?: string | null;
+    deletedBy?: string | null;
+    [key: string]: unknown;
+};
+export type EventRecord = {
+    jobEventId?: string;
+    eventId?: string;
+    id?: string;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    description?: string;
+    active?: boolean;
+    type?: string;
+    targetType?: string;
+    targetId?: string;
+    targetVersion?: number | null;
+    targetConfig?: Record<string, unknown> | null;
+    filter?: Record<string, unknown> | null;
+    version?: number;
+    metadata?: Record<string, unknown>;
+    metaData?: Record<string, unknown>;
+    resourceMetadata?: Record<string, unknown>;
+    deletedAt?: string | null;
+    deletedBy?: string | null;
+    [key: string]: unknown;
+};

package/dist/src/ui.d.ts

@@ -10,11 +10,13 @@ export declare function renderRuntimeInfo(input: {
     nodeVersion: string;
     configDir: string;
     runtime: RuntimeConfig;
+    environmentName?: string;
     auth: AuthViewState;
 }): string;
 export declare function renderAuthStatus(input: {
     configDir: string;
     runtime: RuntimeConfig;
+    environmentName?: string;
     auth: AuthViewState;
 }): string;
 export declare function renderOverview(input: {
@@ -22,5 +24,6 @@ export declare function renderOverview(input: {
     nodeVersion: string;
     configDir: string;
     runtime: RuntimeConfig;
+    environmentName?: string;
     auth: AuthViewState;
 }): string;