@zintrust/core 0.1.28 → 0.1.29

package/src/cli/commands/WorkerCommands.js

@@ -0,0 +1,288 @@
+/* eslint-disable no-console */
+/**
+ * Worker Management CLI Commands
+ * Command-line interface for managing workers
+ */
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { BaseCommand } from '../BaseCommand.js';
+import { Logger } from '../../config/logger.js';
+// Lazy initialization to prevent temporal dead zone issues
+let WorkerFactory;
+let WorkerRegistry;
+let HealthMonitor;
+let ResourceMonitor;
+let workersModulePromise;
+const loadWorkersModule = async () => {
+    workersModulePromise ??= import('../../../packages/workers/src/index.js');
+    try {
+        return await workersModulePromise;
+    }
+    catch (error) {
+        Logger.error('Failed to load optional package "@zintrust/workers"; worker commands require this package.', error);
+        throw ErrorFactory.createCliError('Optional package "@zintrust/workers" is required for worker commands. Install it to use worker:* commands.');
+    }
+};
+const getWorkerFactory = async () => {
+    if (!WorkerFactory) {
+        const mod = await loadWorkersModule();
+        WorkerFactory = mod.WorkerFactory;
+    }
+    return WorkerFactory;
+};
+const getWorkerRegistry = async () => {
+    if (!WorkerRegistry) {
+        const mod = await loadWorkersModule();
+        WorkerRegistry = mod.WorkerRegistry;
+    }
+    return WorkerRegistry;
+};
+const getHealthMonitor = async () => {
+    if (!HealthMonitor) {
+        const mod = await loadWorkersModule();
+        HealthMonitor = mod.HealthMonitor;
+    }
+    return HealthMonitor;
+};
+const getResourceMonitor = async () => {
+    if (!ResourceMonitor) {
+        const mod = await loadWorkersModule();
+        ResourceMonitor = mod.ResourceMonitor;
+    }
+    return ResourceMonitor;
+};
+/**
+ * Helper: Format table output
+ */
+const formatTable = (headers, rows) => {
+    const columnWidths = headers.map((h, i) => {
+        const maxRowWidth = Math.max(...rows.map((r) => (r[i] || '').length));
+        return Math.max(h.length, maxRowWidth);
+    });
+    const headerRow = headers.map((h, i) => h.padEnd(columnWidths[i])).join(' | ');
+    const separator = columnWidths.map((w) => '-'.repeat(w)).join('-+-');
+    const dataRows = rows.map((row) => row.map((cell, i) => (cell || '').padEnd(columnWidths[i])).join(' | '));
+    return [headerRow, separator, ...dataRows].join('\n');
+};
+/**
+ * Worker List Command
+ */
+const createWorkerListCommand = () => {
+    const ext = async () => {
+        try {
+            const workers = await (await getWorkerFactory()).listPersisted();
+            console.log(`\nTotal Workers: ${workers.length}\n`);
+            if (workers.length === 0) {
+                console.log('No workers found.');
+                return;
+            }
+            const registry = await getWorkerRegistry();
+            const rows = workers.map((name) => {
+                const status = registry.status(name);
+                return [
+                    name,
+                    status?.status ?? 'unknown',
+                    status?.version ?? 'N/A',
+                    status?.queueName ?? 'N/A',
+                    String(status?.concurrency ?? 0),
+                ];
+            });
+            console.log(formatTable(['Name', 'Status', 'Version', 'Queue', 'Concurrency'], rows));
+            console.log();
+        }
+        catch (error) {
+            Logger.error('worker:list command failed', error);
+            process.exit(1);
+        }
+    };
+    const cmd = BaseCommand.create({
+        name: 'worker:list',
+        description: 'List all workers',
+        execute: async () => ext(),
+    });
+    return cmd;
+};
+/**
+ * Worker Status Command
+ */
+const createWorkerStatusCommand = () => {
+    const ext = async (name) => {
+        try {
+            if (!name) {
+                Logger.error('Error: Worker name is required');
+                process.exit(1);
+            }
+            const status = (await getWorkerRegistry()).status(name);
+            const health = await (await getWorkerFactory()).getHealth(name);
+            const healthData = typeof health === 'object' && health !== null
+                ? health
+                : {};
+            const metrics = await (await getWorkerFactory()).getMetrics(name);
+            console.log(`\n=== Worker: ${name} ===\n`);
+            console.log(`Status: ${status?.status}`);
+            console.log(`Version: ${status?.version}`);
+            console.log(`Queue: ${status?.queueName}`);
+            console.log(`Region: ${status?.region ?? 'N/A'}`);
+            console.log(`Started: ${status?.startedAt}`);
+            console.log(`Concurrency: ${status?.concurrency}`);
+            console.log(`\nHealth Score: ${healthData.score ?? 'N/A'}`);
+            console.log(`Health Status: ${healthData.status ?? 'N/A'}`);
+            console.log(`\nMetrics:`);
+            console.log(JSON.stringify(metrics, null, 2));
+            console.log();
+        }
+        catch (error) {
+            Logger.error('worker:status command failed', error);
+            process.exit(1);
+        }
+    };
+    const cmd = BaseCommand.create({
+        name: 'worker:status',
+        description: 'Get detailed status of a worker',
+        addOptions: (command) => {
+            command.argument('<name>', 'Worker name');
+        },
+        execute: async (options) => ext(options.args?.[0] ?? ''),
+    });
+    return cmd;
+};
+/**
+ * Worker Start Command
+ */
+const createWorkerStartCommand = () => {
+    const ext = async (name) => {
+        try {
+            if (!name) {
+                Logger.error('Error: Worker name is required');
+                process.exit(1);
+            }
+            await (await getWorkerFactory()).start(name);
+            Logger.info(`✓ Worker "${name}" started successfully`);
+        }
+        catch (error) {
+            Logger.error('worker:start command failed', error);
+            process.exit(1);
+        }
+    };
+    const cmd = BaseCommand.create({
+        name: 'worker:start',
+        description: 'Start a worker',
+        addOptions: (command) => {
+            command.argument('<name>', 'Worker name');
+        },
+        execute: async (options) => ext(options.args?.[0] ?? ''),
+    });
+    return cmd;
+};
+/**
+ * Worker Stop Command
+ */
+const createWorkerStopCommand = () => {
+    const ext = async (name) => {
+        try {
+            if (!name) {
+                console.error('Error: Worker name is required');
+                process.exit(1);
+            }
+            await (await getWorkerFactory()).stop(name);
+            console.log(`✓ Worker "${name}" stopped successfully`);
+        }
+        catch (error) {
+            Logger.error('worker:stop command failed', error);
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    };
+    const cmd = BaseCommand.create({
+        name: 'worker:stop',
+        description: 'Stop a worker',
+        addOptions: (command) => {
+            command.argument('<name>', 'Worker name');
+        },
+        execute: async (options) => ext(options.args?.[0] ?? ''),
+    });
+    return cmd;
+};
+/**
+ * Worker Restart Command
+ */
+const createWorkerRestartCommand = () => {
+    const ext = async (name) => {
+        try {
+            if (!name) {
+                console.error('Error: Worker name is required');
+                process.exit(1);
+            }
+            await (await getWorkerFactory()).restart(name);
+            console.log(`✓ Worker "${name}" restarted successfully`);
+        }
+        catch (error) {
+            Logger.error('worker:restart command failed', error);
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    };
+    const cmd = BaseCommand.create({
+        name: 'worker:restart',
+        description: 'Restart a worker',
+        addOptions: (command) => {
+            command.argument('<name>', 'Worker name');
+        },
+        execute: async (options) => ext(options.args?.[0] ?? ''),
+    });
+    return cmd;
+};
+/**
+ * Worker Summary Command
+ */
+const createWorkerSummaryCommand = () => {
+    const ext = async () => {
+        try {
+            const workers = (await getWorkerFactory()).list();
+            const monitoringSummary = (await getHealthMonitor()).getSummary();
+            const resourceUsage = (await getResourceMonitor()).getCurrentUsage('system');
+            console.log(`\n=== Worker System Summary ===\n`);
+            console.log(`Total Workers: ${workers.length}`);
+            console.log(`\nHealth Overview:`);
+            const healthCounts = {
+                healthy: 0,
+                degraded: 0,
+                unhealthy: 0,
+                critical: 0,
+            };
+            monitoringSummary.forEach((w) => {
+                healthCounts[w.status]++;
+            });
+            console.log(`  Healthy: ${healthCounts.healthy}`);
+            console.log(`  Degraded: ${healthCounts.degraded}`);
+            console.log(`  Unhealthy: ${healthCounts.unhealthy}`);
+            console.log(`  Critical: ${healthCounts.critical}`);
+            console.log(`\nSystem Resources:`);
+            console.log(`  CPU: ${resourceUsage.cpu.toFixed(1)}%`);
+            console.log(`  Memory: ${resourceUsage.memory.percent.toFixed(1)}% (${(resourceUsage.memory.used / 1024 / 1024 / 1024).toFixed(2)} GB used)`);
+            console.log(`  Cost (hourly): $${resourceUsage.cost.hourly.toFixed(2)}`);
+            console.log(`  Cost (daily): $${resourceUsage.cost.daily.toFixed(2)}`);
+            console.log();
+        }
+        catch (error) {
+            Logger.error('worker:summary command failed', error);
+            process.exit(1);
+        }
+    };
+    const cmd = BaseCommand.create({
+        name: 'worker:summary',
+        description: 'Get system-wide worker summary',
+        execute: async () => ext(),
+    });
+    return cmd;
+};
+/**
+ * Export worker command creators
+ */
+export const WorkerCommands = {
+    createWorkerListCommand,
+    createWorkerStatusCommand,
+    createWorkerStartCommand,
+    createWorkerStopCommand,
+    createWorkerRestartCommand,
+    createWorkerSummaryCommand,
+};

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

@@ -0,0 +1,9 @@
+import { type IBaseCommand } from '../BaseCommand';
+import { type QueueWorkKind } from '../workers/QueueWorkRunner';
+export declare function createKindWorkCommand(options: {
+    name: string;
+    description: string;
+    kind: QueueWorkKind;
+    helpHint: string;
+}): IBaseCommand;
+//# sourceMappingURL=createKindWorkCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createKindWorkCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/createKindWorkCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEvF,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAUnF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,YAAY,CAsCf"}

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,24 @@
+/**
+ * CLI Commands Module Index
+ */
+export { AddCommand } from '../commands/AddCommand';
+export { BroadcastWorkCommand } from '../commands/BroadcastWorkCommand';
+export { ConfigCommand } from '../commands/ConfigCommand';
+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 { 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,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,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,23 @@
+/**
+ * CLI Commands Module Index
+ */
+export { AddCommand } from '../commands/AddCommand.js';
+export { BroadcastWorkCommand } from '../commands/BroadcastWorkCommand.js';
+export { ConfigCommand } from '../commands/ConfigCommand.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 { 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 DENO_RUNNER_SOURCE: string;
+export declare const LAMBDA_RUNNER_SOURCE: 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":"AAAA,eAAO,MAAM,kBAAkB,QAwDnB,CAAC;AAEb,eAAO,MAAM,oBAAoB,QAiFrB,CAAC"}

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

@@ -0,0 +1,139 @@
+export const DENO_RUNNER_SOURCE = [
+    "import http from 'node:http';",
+    "import { deno } from '@zintrust/core/start';",
+    '',
+    "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');
+export const LAMBDA_RUNNER_SOURCE = [
+    "import http from 'node:http';",
+    "import { handler as lambdaHandler } from '@zintrust/core/start';",
+    '',
+    "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');

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,EACV,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAYjD,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;AAkHD;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;wBACgB,MAAM,GAAgC,cAAc;IAqCvE;;OAEG;6BAC4B,OAAO,CAAC,IAAI,CAAC;IAS5C;;OAEG;uBACsB,OAAO,CAAC,cAAc,CAAC;IAOhD;;OAEG;wBACuB,OAAO,CAAC,cAAc,CAAC;EAKjD,CAAC"}