@zintrust/core 0.4.17 → 0.4.19

package/src/cli/commands/createKindWorkCommand.js

@@ -0,0 +1,33 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { QueueWorkCommandUtils } from '../commands/QueueWorkCommandUtils.js';
+import { QueueWorkRunner } from '../workers/QueueWorkRunner.js';
+export function createKindWorkCommand(options) {
+    return BaseCommand.create({
+        name: options.name,
+        description: options.description,
+        addOptions: (command) => {
+            command
+                .argument('<queueName>', 'Queue name to work')
+                .option('--timeout <seconds>', 'Stop after this many seconds (default: 10)')
+                .option('--retry <count>', 'Retries after first attempt (default: 3)')
+                .option('--max-items <count>', 'Max items to process in one run (default: 1000)')
+                .option('--driver <name>', 'Queue driver name (default: from QUEUE_DRIVER)');
+        },
+        execute: async (cmdOptions) => {
+            const queueName = QueueWorkCommandUtils.requireQueueNameFromArgs(cmdOptions.args, options.helpHint);
+            const timeoutSeconds = QueueWorkCommandUtils.parsePositiveInt(cmdOptions.timeout, '--timeout');
+            const retry = QueueWorkCommandUtils.parseNonNegativeInt(cmdOptions.retry, '--retry');
+            const maxItems = QueueWorkCommandUtils.parsePositiveInt(cmdOptions.maxItems, '--max-items');
+            const driverName = QueueWorkCommandUtils.normalizeDriverName(cmdOptions.driver);
+            const result = await QueueWorkRunner.run({
+                kind: options.kind,
+                queueName,
+                timeoutSeconds,
+                retry,
+                maxItems,
+                driverName,
+            });
+            QueueWorkCommandUtils.logSummary(queueName, options.kind, result);
+        },
+    });
+}

package/src/cli/commands/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * CLI Commands Module Index
+ */
+export { AddCommand } from '../commands/AddCommand';
+export { BroadcastWorkCommand } from '../commands/BroadcastWorkCommand';
+export { ConfigCommand } from '../commands/ConfigCommand';
+export { ContainerWorkersCommand } from '../commands/ContainerWorkersCommand';
+export { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from '../commands/CreateCommand';
+export { DebugCommand } from '../commands/DebugCommand';
+export { JwtDevCommand } from '../commands/JwtDevCommand';
+export { LogsCleanupCommand } from '../commands/LogsCleanupCommand';
+export { MakeMailTemplateCommand } from '../commands/MakeMailTemplateCommand';
+export { MakeNotificationTemplateCommand } from '../commands/MakeNotificationTemplateCommand';
+export { MigrateCommand } from '../commands/MigrateCommand';
+export { MigrateWorkerCommand } from '../commands/MigrateWorkerCommand';
+export { NewCommand } from '../commands/NewCommand';
+export { NotificationWorkCommand } from '../commands/NotificationWorkCommand';
+export { PrepareCommand } from '../commands/PrepareCommand';
+export { QueueCommand } from '../commands/QueueCommand';
+export { QueueRecoveryCommand } from '../commands/QueueRecoveryCommand';
+export { ResourceControlCommand } from '../commands/ResourceControlCommand';
+export { RoutesCommand } from '../commands/RoutesCommand';
+export { SecretsCommand } from '../commands/SecretsCommand';
+export { StartCommand } from '../commands/StartCommand';
+export { TemplatesCommand } from '../commands/TemplatesCommand';
+//# sourceMappingURL=index.d.ts.map

package/src/cli/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,+BAA+B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}

package/src/cli/commands/index.js

@@ -0,0 +1,25 @@
+/**
+ * CLI Commands Module Index
+ */
+export { AddCommand } from '../commands/AddCommand.js';
+export { BroadcastWorkCommand } from '../commands/BroadcastWorkCommand.js';
+export { ConfigCommand } from '../commands/ConfigCommand.js';
+export { ContainerWorkersCommand } from '../commands/ContainerWorkersCommand.js';
+export { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from '../commands/CreateCommand.js';
+export { DebugCommand } from '../commands/DebugCommand.js';
+export { JwtDevCommand } from '../commands/JwtDevCommand.js';
+export { LogsCleanupCommand } from '../commands/LogsCleanupCommand.js';
+export { MakeMailTemplateCommand } from '../commands/MakeMailTemplateCommand.js';
+export { MakeNotificationTemplateCommand } from '../commands/MakeNotificationTemplateCommand.js';
+export { MigrateCommand } from '../commands/MigrateCommand.js';
+export { MigrateWorkerCommand } from '../commands/MigrateWorkerCommand.js';
+export { NewCommand } from '../commands/NewCommand.js';
+export { NotificationWorkCommand } from '../commands/NotificationWorkCommand.js';
+export { PrepareCommand } from '../commands/PrepareCommand.js';
+export { QueueCommand } from '../commands/QueueCommand.js';
+export { QueueRecoveryCommand } from '../commands/QueueRecoveryCommand.js';
+export { ResourceControlCommand } from '../commands/ResourceControlCommand.js';
+export { RoutesCommand } from '../commands/RoutesCommand.js';
+export { SecretsCommand } from '../commands/SecretsCommand.js';
+export { StartCommand } from '../commands/StartCommand.js';
+export { TemplatesCommand } from '../commands/TemplatesCommand.js';

package/src/cli/commands/runner/index.d.ts

@@ -0,0 +1,3 @@
+export declare const createDenoRunnerSource: (startModuleSpecifier: string) => string;
+export declare const createLambdaRunnerSource: (startModuleSpecifier: string) => string;
+//# sourceMappingURL=index.d.ts.map

package/src/cli/commands/runner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/runner/index.ts"],"names":[],"mappings":"AAoJA,eAAO,MAAM,sBAAsB,GAAI,sBAAsB,MAAM,KAAG,MAErE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,sBAAsB,MAAM,KAAG,MAEvE,CAAC"}

package/src/cli/commands/runner/index.js

@@ -0,0 +1,150 @@
+const quote = (value) => JSON.stringify(value);
+const START_MODULE_PLACEHOLDER = '__ZINTRUST_START_MODULE__';
+const injectStartModuleSpecifier = (template, startModuleSpecifier) => {
+    return template.replaceAll(START_MODULE_PLACEHOLDER, quote(startModuleSpecifier));
+};
+const denoRunnerTemplate = [
+    "import http from 'node:http';",
+    `import { deno } from ${START_MODULE_PLACEHOLDER};`,
+    '',
+    "const port = Number.parseInt(process.env.PORT ?? '3000', 10) || 3000;",
+    "const host = process.env.HOST ?? 'localhost';",
+    '',
+    'const readBody = async (req: http.IncomingMessage): Promise<Buffer | undefined> => {',
+    "  if (req.method === 'GET' || req.method === 'HEAD') return undefined;",
+    '  const chunks: Buffer[] = [];',
+    '  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));',
+    '  return chunks.length > 0 ? Buffer.concat(chunks) : undefined;',
+    '};',
+    '',
+    'const server = http.createServer(async (req, res) => {',
+    '  try {',
+    "    const proto = (req.headers['x-forwarded-proto'] ?? 'http').toString();",
+    '    const authority = (req.headers.host ?? host).toString();',
+    "    const url = new URL(req.url ?? '/', proto + '://' + authority);",
+    '',
+    '    const headers = new Headers();',
+    '    for (const [key, value] of Object.entries(req.headers)) {',
+    '      if (value === undefined) continue;',
+    '      if (Array.isArray(value)) {',
+    '        for (const v of value) headers.append(key, v);',
+    '      } else {',
+    '        headers.set(key, String(value));',
+    '      }',
+    '    }',
+    '',
+    '    const body = await readBody(req);',
+    '    const request = new Request(url.toString(), {',
+    "      method: req.method ?? 'GET',",
+    '      headers,',
+    '      body,',
+    '    });',
+    '',
+    '    const response = await deno(request);',
+    '',
+    '    res.statusCode = response.status;',
+    '    response.headers.forEach((v, k) => res.setHeader(k, v));',
+    '',
+    '    const ab = await response.arrayBuffer();',
+    '    res.end(Buffer.from(ab));',
+    '  } catch (err) {',
+    '    res.statusCode = 500;',
+    "    res.setHeader('content-type', 'text/plain');",
+    "    res.end('Internal Server Error' + (err as Error).message);",
+    '  }',
+    '});',
+    '',
+    'server.listen(port, host, () => {',
+    '  // eslint-disable-next-line no-console',
+    "  console.log('Deno adapter server listening at http://' + host + ':' + port);",
+    '});',
+    '',
+].join('\n');
+const lambdaRunnerTemplate = [
+    "import http from 'node:http';",
+    `import { handler as lambdaHandler } from ${START_MODULE_PLACEHOLDER};`,
+    '',
+    "const port = Number.parseInt(process.env.PORT ?? '3000', 10) || 3000;",
+    "const host = process.env.HOST ?? 'localhost';",
+    '',
+    'const readBody = async (req: http.IncomingMessage): Promise<string | undefined> => {',
+    "  if (req.method === 'GET' || req.method === 'HEAD') return undefined;",
+    '  const chunks: Buffer[] = [];',
+    '  for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));',
+    "  return chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : undefined;",
+    '};',
+    '',
+    'const server = http.createServer(async (req, res) => {',
+    '  try {',
+    "    const proto = (req.headers['x-forwarded-proto'] ?? 'http').toString();",
+    '    const authority = (req.headers.host ?? host).toString();',
+    "    const url = new URL(req.url ?? '/', proto + '://' + authority);",
+    '',
+    '    const body = await readBody(req);',
+    '    const headers: Record<string, string> = {};',
+    '    for (const [k, v] of Object.entries(req.headers)) {',
+    '      if (v === undefined) continue;',
+    "      headers[k] = Array.isArray(v) ? v.join(',') : String(v);",
+    '    }',
+    '',
+    '    const queryStringParameters: Record<string, string> = {};',
+    '    url.searchParams.forEach((value, key) => {',
+    '      if (queryStringParameters[key] === undefined) queryStringParameters[key] = value;',
+    '    });',
+    '',
+    '    const event = {',
+    "      version: '2.0',",
+    "      routeKey: '$default',",
+    '      rawPath: url.pathname,',
+    '      rawQueryString: url.searchParams.toString(),',
+    '      headers,',
+    '      queryStringParameters,',
+    '      requestContext: {',
+    '        http: {',
+    "          method: req.method ?? 'GET',",
+    '          path: url.pathname,',
+    "          sourceIp: (req.socket.remoteAddress ?? '').toString(),",
+    '        },',
+    '      },',
+    '      body: body ?? null,',
+    '      isBase64Encoded: false,',
+    '    };',
+    '',
+    '    const result = (await lambdaHandler(event, {})) as {',
+    '      statusCode?: number;',
+    '      headers?: Record<string, string | string[]>;',
+    '      body?: string;',
+    '      isBase64Encoded?: boolean;',
+    '    };',
+    '',
+    '    res.statusCode = typeof result.statusCode === "number" ? result.statusCode : 200;',
+    '    if (result.headers) {',
+    '      for (const [k, v] of Object.entries(result.headers)) {',
+    '        res.setHeader(k, v as any);',
+    '      }',
+    '    }',
+    '',
+    '    if (result.isBase64Encoded === true && typeof result.body === "string") {',
+    "      res.end(Buffer.from(result.body, 'base64'));",
+    '    } else {',
+    "      res.end(result.body ?? '');",
+    '    }',
+    '  } catch {',
+    '    res.statusCode = 500;',
+    "    res.setHeader('content-type', 'application/json');",
+    "    res.end(JSON.stringify({ message: 'Internal Server Error' }));",
+    '  }',
+    '});',
+    '',
+    'server.listen(port, host, () => {',
+    '  // eslint-disable-next-line no-console',
+    "  console.log('Lambda adapter server listening at http://' + host + ':' + port);",
+    '});',
+    '',
+].join('\n');
+export const createDenoRunnerSource = (startModuleSpecifier) => {
+    return injectStartModuleSpecifier(denoRunnerTemplate, startModuleSpecifier);
+};
+export const createLambdaRunnerSource = (startModuleSpecifier) => {
+    return injectStartModuleSpecifier(lambdaRunnerTemplate, startModuleSpecifier);
+};

package/src/cli/commands/schedule/ScheduleCliSupport.d.ts

@@ -0,0 +1,6 @@
+export declare const ScheduleCliSupport: Readonly<{
+    registerAll(): Promise<void>;
+    shutdownCliResources: () => Promise<void>;
+}>;
+export default ScheduleCliSupport;
+//# sourceMappingURL=ScheduleCliSupport.d.ts.map

package/src/cli/commands/schedule/ScheduleCliSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleCliSupport.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/schedule/ScheduleCliSupport.ts"],"names":[],"mappings":"AAwDA,eAAO,MAAM,kBAAkB;mBACR,OAAO,CAAC,IAAI,CAAC;gCA1BG,OAAO,CAAC,IAAI,CAAC;EAmClD,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/src/cli/commands/schedule/ScheduleCliSupport.js

@@ -0,0 +1,55 @@
+import { databaseConfig } from '../../../config/database.js';
+import { registerDatabasesFromRuntimeConfig } from '../../../orm/DatabaseRuntimeRegistration.js';
+import { SchedulerRuntime } from '../../../scheduler/SchedulerRuntime.js';
+const isSchedule = (value) => {
+    if (value === undefined || value === null || typeof value !== 'object')
+        return false;
+    return 'name' in value && typeof value.name === 'string';
+};
+const loadScheduleModules = async () => {
+    const coreSchedules = await import('../../../schedules/index.js');
+    let appSchedules = {};
+    try {
+        appSchedules = (await import('../../../../app/Schedules/index.js'));
+    }
+    catch {
+        appSchedules = {};
+    }
+    return {
+        core: Object.values(coreSchedules).filter(isSchedule),
+        app: Object.values(appSchedules).filter(isSchedule),
+    };
+};
+const shutdownCliResources = async () => {
+    try {
+        const mod = await import('../../../orm/ConnectionManager.js');
+        await mod.ConnectionManager.shutdownIfInitialized();
+    }
+    catch {
+        // best-effort
+    }
+    try {
+        const mod = await import('../../../orm/Database.js');
+        await mod.resetDatabase();
+    }
+    catch {
+        // best-effort
+    }
+    try {
+        const mod = (await import('../../../tools/queue/LockProvider.js'));
+        await mod.closeLockProvider?.();
+    }
+    catch {
+        // best-effort
+    }
+};
+export const ScheduleCliSupport = Object.freeze({
+    async registerAll() {
+        registerDatabasesFromRuntimeConfig(databaseConfig);
+        const modules = await loadScheduleModules();
+        SchedulerRuntime.registerMany(modules.core, 'core');
+        SchedulerRuntime.registerMany(modules.app, 'app');
+    },
+    shutdownCliResources,
+});
+export default ScheduleCliSupport;

package/src/cli/config/ConfigManager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import type { ProjectConfig } from '../config/ConfigSchema';
+export interface IConfigManager {
+    load(): Promise<ProjectConfig>;
+    save(config?: ProjectConfig): Promise<void>;
+    getConfig(): ProjectConfig;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    exists(): Promise<boolean>;
+    create(initialConfig?: Partial<ProjectConfig>): Promise<void>;
+    reset(): Promise<void>;
+    merge(partial: Partial<ProjectConfig>): void;
+    export(): string;
+    getAllKeys(): string[];
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export declare const ConfigManager: Readonly<{
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath?: string): IConfigManager;
+    /**
+     * Create global config directory if not exists
+     */
+    ensureGlobalConfigDir(): Promise<void>;
+    /**
+     * Get or create global config manager
+     */
+    getGlobalConfig(): Promise<IConfigManager>;
+    /**
+     * Get or create project config manager
+     */
+    getProjectConfig(): Promise<IConfigManager>;
+}>;
+//# sourceMappingURL=ConfigManager.d.ts.map

package/src/cli/config/ConfigManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigManager.d.ts","sourceRoot":"","sources":["../../../../src/cli/config/ConfigManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAgB9D,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/B,IAAI,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,IAAI,aAAa,CAAC;IAC3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,MAAM,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC7C,MAAM,IAAI,MAAM,CAAC;IACjB,UAAU,IAAI,MAAM,EAAE,CAAC;CACxB;AAqHD;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;wBACgB,MAAM,GAAgC,cAAc;IAqCvE;;OAEG;6BAC4B,OAAO,CAAC,IAAI,CAAC;IAU5C;;OAEG;uBACsB,OAAO,CAAC,cAAc,CAAC;IAOhD;;OAEG;wBACuB,OAAO,CAAC,cAAc,CAAC;EAKjD,CAAC"}

package/src/cli/config/ConfigManager.js

@@ -0,0 +1,182 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import { ConfigPaths, DEFAULT_CONFIG, getConfigValue, setConfigValue, } from '../config/ConfigSchema.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import * as path from '../../node-singletons/path.js';
+const loadFsPromises = async () => {
+    const mod = await import('../../node-singletons/fs.js');
+    return mod.fsPromises;
+};
+/**
+ * Deep merge helper
+ */
+const deepMerge = (target, source) => {
+    const result = { ...target };
+    for (const key in source) {
+        if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] ?? {}, source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+};
+/**
+ * Load configuration from file
+ */
+async function loadConfig(state) {
+    try {
+        const fs = await loadFsPromises();
+        const content = await fs.readFile(state.configPath, 'utf-8');
+        state.config = JSON.parse(content);
+        return state.config;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            Logger.debug(`Config file not found at ${state.configPath}, using defaults`);
+            state.config = structuredClone(DEFAULT_CONFIG);
+            return state.config;
+        }
+        ErrorFactory.createCliError(`Failed to load config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Save configuration to file
+ */
+async function saveConfig(state, newConfig) {
+    const toSave = newConfig ?? state.config;
+    if (!toSave) {
+        throw ErrorFactory.createConfigError('No configuration to save');
+    }
+    try {
+        const fs = await loadFsPromises();
+        // Ensure directory exists
+        const dir = path.dirname(state.configPath);
+        if (dir !== '.') {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        // Write config with nice formatting
+        await fs.writeFile(state.configPath, JSON.stringify(toSave, null, 2));
+        state.config = toSave;
+        Logger.debug(`Config saved to ${state.configPath}`);
+    }
+    catch (err) {
+        ErrorFactory.createCliError(`Failed to save config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Get current configuration
+ */
+function getConfig(state) {
+    state.config ??= structuredClone(DEFAULT_CONFIG);
+    return state.config;
+}
+/**
+ * Check if config file exists
+ */
+async function configExists(configPath) {
+    try {
+        const fs = await loadFsPromises();
+        await fs.access(configPath);
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Config file access check failed', error);
+        return false;
+    }
+}
+/**
+ * Flatten object keys
+ */
+function flattenKeys(obj, prefix = '') {
+    const keys = [];
+    for (const key in obj) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        const value = obj[key];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            keys.push(...flattenKeys(value, fullKey));
+        }
+        else {
+            keys.push(fullKey);
+        }
+    }
+    return keys;
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export const ConfigManager = Object.freeze({
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath = ConfigPaths.PROJECT_CONFIG) {
+        const state = {
+            config: null,
+            configPath,
+        };
+        return {
+            load: async () => loadConfig(state),
+            save: async (newConfig) => saveConfig(state, newConfig),
+            getConfig: () => getConfig(state),
+            get(key) {
+                return getConfigValue(getConfig(state), key);
+            },
+            set(key, value) {
+                setConfigValue(getConfig(state), key, value);
+            },
+            exists: async () => configExists(configPath),
+            async create(initialConfig) {
+                const newConfig = { ...DEFAULT_CONFIG, ...initialConfig };
+                await saveConfig(state, newConfig);
+            },
+            async reset() {
+                state.config = structuredClone(DEFAULT_CONFIG);
+                await saveConfig(state);
+            },
+            merge(partial) {
+                const currentConfig = getConfig(state);
+                state.config = deepMerge(currentConfig, partial);
+            },
+            export: () => JSON.stringify(getConfig(state), null, 2),
+            getAllKeys: () => flattenKeys(getConfig(state)),
+        };
+    },
+    /**
+     * Create global config directory if not exists
+     */
+    async ensureGlobalConfigDir() {
+        try {
+            const fs = await loadFsPromises();
+            await fs.mkdir(ConfigPaths.GLOBAL_DIR, { recursive: true });
+        }
+        catch (err) {
+            ErrorFactory.createCliError('Could not create global config dir', err);
+            Logger.debug(`Could not create global config dir: ${err.message}`);
+        }
+    },
+    /**
+     * Get or create global config manager
+     */
+    async getGlobalConfig() {
+        await this.ensureGlobalConfigDir();
+        const manager = this.create(ConfigPaths.GLOBAL_CONFIG);
+        await manager.load();
+        return manager;
+    },
+    /**
+     * Get or create project config manager
+     */
+    async getProjectConfig() {
+        const manager = this.create(ConfigPaths.PROJECT_CONFIG);
+        await manager.load();
+        return manager;
+    },
+});