@bpinhosilva/agent-orchestrator 1.0.0-alpha.32 → 1.0.0-alpha.33

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.0.0-alpha.33](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.32...v1.0.0-alpha.33) (2026-04-06)
+
+
+### Features
+
+* **cli:** refactor project, split into multiple components ([f18903b](https://github.com/bpinhosilva/agent-orchestrator/commit/f18903be0b1b09a1e651918d081d96267bfe2bc6))
+
 # [1.0.0-alpha.32](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.31...v1.0.0-alpha.32) (2026-04-06)
 
 

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerAllCommands(program: Command): void;

package/dist/cli/commands/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAllCommands = registerAllCommands;
+const setup_command_1 = require("./setup.command");
+const run_command_1 = require("./run.command");
+const stop_command_1 = require("./stop.command");
+const status_command_1 = require("./status.command");
+const logs_command_1 = require("./logs.command");
+const migrate_command_1 = require("./migrate.command");
+function registerAllCommands(program) {
+    (0, setup_command_1.registerSetupCommand)(program);
+    (0, run_command_1.registerRunCommand)(program);
+    (0, stop_command_1.registerStopCommand)(program);
+    (0, status_command_1.registerStatusCommand)(program);
+    (0, logs_command_1.registerLogsCommand)(program);
+    (0, migrate_command_1.registerMigrateCommand)(program);
+}

package/dist/cli/commands/logs.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLogsCommand(program: Command): void;

package/dist/cli/commands/logs.command.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLogsCommand = registerLogsCommand;
+const fs = __importStar(require("fs"));
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+function registerLogsCommand(program) {
+    program
+        .command('logs')
+        .description('Print the most recent orchestrator log lines')
+        .option('-n, --lines <count>', 'Number of log lines to print', '50')
+        .option('-f, --follow', 'Follow log output (like tail -f)', false)
+        .action((...args) => {
+        const opts = (0, utils_1.resolveActionOptions)(args);
+        try {
+            if (!fs.existsSync(constants_1.LOG_FILE)) {
+                console.log(`No log file found at ${constants_1.LOG_FILE}.`);
+                return;
+            }
+            const lineCount = Number(opts.lines || '50');
+            if (!Number.isInteger(lineCount) || lineCount < 1) {
+                throw new Error('The --lines option must be a positive integer.');
+            }
+            const content = fs.readFileSync(constants_1.LOG_FILE, 'utf8');
+            const output = (0, utils_1.tailLogLines)(content, lineCount);
+            if (output) {
+                console.log(output);
+            }
+            else if (!opts.follow) {
+                console.log('Log file is empty.');
+            }
+            if (opts.follow) {
+                let position = fs.statSync(constants_1.LOG_FILE).size;
+                fs.watchFile(constants_1.LOG_FILE, { interval: 200 }, () => {
+                    try {
+                        const stat = fs.statSync(constants_1.LOG_FILE);
+                        if (stat.size > position) {
+                            const length = stat.size - position;
+                            const buffer = Buffer.alloc(length);
+                            const fd = fs.openSync(constants_1.LOG_FILE, 'r');
+                            fs.readSync(fd, buffer, 0, length, position);
+                            fs.closeSync(fd);
+                            position = stat.size;
+                            process.stdout.write(buffer.toString('utf8'));
+                        }
+                    }
+                    catch {
+                        // log file may have been rotated; ignore
+                    }
+                });
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to read logs: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/migrate.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerMigrateCommand(program: Command): void;

package/dist/cli/commands/migrate.command.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMigrateCommand = registerMigrateCommand;
+const utils_1 = require("../utils");
+const migration_state_1 = require("../../database/migration-state");
+async function confirmAction(message, autoConfirm = false) {
+    if (autoConfirm) {
+        return true;
+    }
+    const enquirer = await Promise.resolve().then(() => __importStar(require('enquirer')));
+    const { confirmed } = await enquirer.prompt({
+        type: 'confirm',
+        name: 'confirmed',
+        message,
+        initial: false,
+    });
+    return confirmed;
+}
+async function promptForEnter(message, autoConfirm = false) {
+    if (autoConfirm) {
+        return;
+    }
+    const enquirer = await Promise.resolve().then(() => __importStar(require('enquirer')));
+    await enquirer.prompt({
+        type: 'input',
+        name: 'continue',
+        message,
+    });
+}
+function registerMigrateCommand(program) {
+    program
+        .command('migrate')
+        .description('Run pending database migrations')
+        .option('-f, --force', 'Force re-initialization (DROP ALL DATA)')
+        .option('-y, --yes', 'Disable confirmation prompts')
+        .action(async (...args) => {
+        const opts = (0, utils_1.resolveActionOptions)(args);
+        try {
+            if (opts.force) {
+                const confirmForce = await confirmAction('Are you absolutely sure you want to DROP ALL DATA and re-initialize?', opts.yes);
+                if (confirmForce) {
+                    await promptForEnter('Press Enter to confirm and start the destructive initialization...', opts.yes);
+                    await (0, migration_state_1.runMigrations)(true);
+                }
+                else {
+                    console.log('Force migration cancelled.');
+                }
+                return;
+            }
+            const { hasPending, isEmpty } = await (0, migration_state_1.checkPendingMigrations)({
+                assumePendingOnError: true,
+            });
+            if (isEmpty) {
+                console.log('Database is empty. Initializing...');
+                await (0, migration_state_1.runMigrations)();
+                return;
+            }
+            if (!hasPending) {
+                console.log('Database is already up to date.');
+                return;
+            }
+            const confirmMigration = await confirmAction('Pending migrations detected. Do you want to run them?', opts.yes);
+            if (confirmMigration) {
+                await (0, migration_state_1.runMigrations)();
+            }
+            else {
+                console.log('Migration cancelled.');
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.error(`Migration failed: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/run.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerRunCommand(program: Command): void;

package/dist/cli/commands/run.command.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunCommand = registerRunCommand;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const process_manager_1 = require("../process-manager");
+const env_1 = require("../env");
+const constants_1 = require("../constants");
+function getConfiguredPort() {
+    const env = (0, env_1.readEnvFile)(constants_1.ENV_PATH);
+    return env.PORT || '15789';
+}
+function registerRunCommand(program) {
+    program
+        .command('run')
+        .description('Start the orchestrator server in detached mode')
+        .action(() => {
+        try {
+            (0, process_manager_1.assertBuildExists)();
+            const existingProcess = (0, process_manager_1.findManagedProcess)();
+            if (existingProcess) {
+                console.log(`Orchestrator is already running.\n${(0, process_manager_1.formatProcessSummary)(existingProcess)}`);
+                return;
+            }
+            console.log('Starting Agent Orchestrator in background...');
+            if (!fs.existsSync(constants_1.PID_DIR)) {
+                fs.mkdirSync(constants_1.PID_DIR, { recursive: true, mode: 0o700 });
+            }
+            const logStream = fs.openSync(constants_1.LOG_FILE, 'a');
+            const child = (0, child_process_1.spawn)('node', [constants_1.MAIN_FILE], {
+                detached: true,
+                stdio: ['ignore', logStream, logStream],
+                cwd: constants_1.PACKAGE_ROOT,
+                env: (0, process_manager_1.getChildEnvironment)(),
+            });
+            const pid = child.pid;
+            if (!pid) {
+                throw new Error('Failed to determine spawned process PID.');
+            }
+            const port = getConfiguredPort();
+            (0, process_manager_1.persistProcessMetadata)({
+                pid,
+                cwd: constants_1.PACKAGE_ROOT,
+                mainPath: constants_1.MAIN_FILE,
+                port,
+                logFile: constants_1.LOG_FILE,
+                startedAt: new Date().toISOString(),
+            });
+            child.unref();
+            console.log(`Orchestrator started in background.\n${(0, process_manager_1.formatProcessSummary)({
+                pid,
+                source: 'metadata',
+                cwd: constants_1.PACKAGE_ROOT,
+                mainPath: constants_1.MAIN_FILE,
+                port,
+            })}`);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to start orchestrator: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/setup.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSetupCommand(program: Command): void;

package/dist/cli/commands/setup.command.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSetupCommand = registerSetupCommand;
+const utils_1 = require("../utils");
+const index_1 = require("../setup/index");
+const migration_state_1 = require("../../database/migration-state");
+function registerSetupCommand(program) {
+    program
+        .command('setup')
+        .description('Create or update the local CLI runtime configuration')
+        .option('--port <port>', 'Server port for the orchestrator runtime')
+        .option('--db-type <type>', 'Database type: sqlite or postgres')
+        .option('--database-url <url>', 'PostgreSQL connection string')
+        .option('--db-logging', 'Enable database query logging')
+        .option('--provider <provider>', 'Configure a provider (gemini, anthropic)', (value, previous = []) => previous.concat(value
+        .split(',')
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean)), [])
+        .option('--gemini-key <key>', 'Google Gemini API key')
+        .option('--anthropic-key <key>', 'Anthropic Claude API key')
+        .option('-y, --yes', 'Disable prompts and use supplied flags/defaults')
+        .option('--skip-admin-setup', 'Skip creating or updating the admin user')
+        .option('--admin-name <name>', 'Admin user name for non-interactive setup')
+        .option('--admin-email <email>', 'Admin user email for non-interactive setup')
+        .option('--admin-password <password>', 'Admin user password for non-interactive setup')
+        .option('--regenerate-jwt-secret', 'Generate a new JWT secret instead of preserving the existing one')
+        .action(async (...args) => {
+        const opts = (0, utils_1.resolveActionOptions)(args);
+        console.log('Starting setup...');
+        try {
+            await (0, index_1.handleSetup)(opts);
+            if (opts.yes) {
+                const { hasPending, isEmpty } = await (0, migration_state_1.checkPendingMigrations)({
+                    assumePendingOnError: true,
+                });
+                if (isEmpty) {
+                    console.log('Database is empty. Initializing...');
+                    await (0, migration_state_1.runMigrations)();
+                }
+                else if (hasPending) {
+                    await (0, migration_state_1.runMigrations)();
+                }
+                else {
+                    console.log('Database is already up to date.');
+                }
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.error(`Setup failed: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/status.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerStatusCommand(program: Command): void;

package/dist/cli/commands/status.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatusCommand = registerStatusCommand;
+const process_manager_1 = require("../process-manager");
+function registerStatusCommand(program) {
+    program
+        .command('status')
+        .description('Show the currently running orchestrator process, if any')
+        .action(() => {
+        try {
+            const runningProcess = (0, process_manager_1.findManagedProcess)();
+            if (!runningProcess) {
+                console.log('Orchestrator is not running.');
+                return;
+            }
+            console.log(`Orchestrator is running.\n${(0, process_manager_1.formatProcessSummary)(runningProcess)}`);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to inspect orchestrator status: ${errorMessage}`);
+        }
+    });
+}

package/dist/cli/commands/stop.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerStopCommand(program: Command): void;

package/dist/cli/commands/stop.command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStopCommand = registerStopCommand;
+const process_manager_1 = require("../process-manager");
+function registerStopCommand(program) {
+    program
+        .command('stop')
+        .description('Stop the orchestrator server after verifying the running process identity')
+        .action(() => {
+        try {
+            const runningProcess = (0, process_manager_1.findManagedProcess)();
+            if (!runningProcess) {
+                console.log('Orchestrator is not running.');
+                return;
+            }
+            console.log(`Stopping Orchestrator after verifying the exact process in ${runningProcess.cwd} (PID: ${runningProcess.pid})...`);
+            process.kill(runningProcess.pid, 'SIGTERM');
+            (0, process_manager_1.removeRuntimeState)();
+            console.log('Orchestrator stop signal sent.');
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to stop orchestrator: ${errorMessage}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/constants.d.ts

@@ -0,0 +1,10 @@
+export { SUPPORTED_PROVIDERS } from './types';
+export declare const PACKAGE_ROOT: string;
+export declare const PACKAGE_JSON_PATH: string;
+export declare const MAIN_FILE: string;
+export declare const UI_INDEX_FILE: string;
+export declare const PID_DIR: string;
+export declare const PID_FILE: string;
+export declare const LOG_FILE: string;
+export declare const ENV_PATH: string;
+export declare const PROCESS_FILE: string;

package/dist/cli/constants.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROCESS_FILE = exports.ENV_PATH = exports.LOG_FILE = exports.PID_FILE = exports.PID_DIR = exports.UI_INDEX_FILE = exports.MAIN_FILE = exports.PACKAGE_JSON_PATH = exports.PACKAGE_ROOT = exports.SUPPORTED_PROVIDERS = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+var types_1 = require("./types");
+Object.defineProperty(exports, "SUPPORTED_PROVIDERS", { enumerable: true, get: function () { return types_1.SUPPORTED_PROVIDERS; } });
+exports.PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+exports.PACKAGE_JSON_PATH = path.join(exports.PACKAGE_ROOT, 'package.json');
+exports.MAIN_FILE = path.join(exports.PACKAGE_ROOT, 'dist/main.js');
+exports.UI_INDEX_FILE = path.join(exports.PACKAGE_ROOT, 'dist/ui/index.html');
+// These are set at process start before any imports, so the env var is always present
+exports.PID_DIR = process.env.AGENT_ORCHESTRATOR_HOME ??
+    path.join(os.homedir(), '.agent-orchestrator');
+exports.PID_FILE = path.join(exports.PID_DIR, 'pid');
+exports.LOG_FILE = path.join(exports.PID_DIR, 'server.log');
+exports.ENV_PATH = path.join(exports.PID_DIR, '.env');
+exports.PROCESS_FILE = path.join(exports.PID_DIR, 'process.json');

package/dist/cli/env.d.ts

@@ -0,0 +1,5 @@
+import type { BasicConfig, FileSystem } from './types';
+export declare function parseEnvContent(content: string): Record<string, string>;
+export declare function readEnvFile(envPath?: string, fsDep?: FileSystem): Record<string, string>;
+export declare function writePrivateFile(filePath: string, content: string, fsDep?: FileSystem): void;
+export declare function buildEnvContent(currentEnv: Record<string, string>, basicConfig: BasicConfig, databaseUrl: string, geminiKey: string, anthropicKey: string, jwtSecret: string, jwtRefreshSecret: string): string;

package/dist/cli/env.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnvContent = parseEnvContent;
+exports.readEnvFile = readEnvFile;
+exports.writePrivateFile = writePrivateFile;
+exports.buildEnvContent = buildEnvContent;
+const fs = __importStar(require("fs"));
+const constants_1 = require("./constants");
+const realFs = fs;
+function parseEnvContent(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'))
+        .reduce((acc, line) => {
+        const separatorIndex = line.indexOf('=');
+        if (separatorIndex === -1) {
+            return acc;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        if (!key || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            return acc;
+        const value = line.slice(separatorIndex + 1).trim();
+        acc[key] = value;
+        return acc;
+    }, {});
+}
+function readEnvFile(envPath = constants_1.ENV_PATH, fsDep = realFs) {
+    if (!fsDep.existsSync(envPath)) {
+        return {};
+    }
+    try {
+        return parseEnvContent(fsDep.readFileSync(envPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writePrivateFile(filePath, content, fsDep = realFs) {
+    fsDep.writeFileSync(filePath, content, { mode: 0o600 });
+    fsDep.chmodSync(filePath, 0o600);
+}
+function buildEnvContent(currentEnv, basicConfig, databaseUrl, geminiKey, anthropicKey, jwtSecret, jwtRefreshSecret) {
+    const envValues = {
+        ...currentEnv,
+        NODE_ENV: 'production',
+        PORT: basicConfig.port,
+        DB_TYPE: basicConfig.dbType,
+        DB_LOGGING: `${basicConfig.dbLogging}`,
+        CHECK_PENDING_MIGRATIONS_ON_STARTUP: currentEnv.CHECK_PENDING_MIGRATIONS_ON_STARTUP || 'true',
+        JWT_SECRET: jwtSecret,
+        JWT_REFRESH_SECRET: jwtRefreshSecret,
+    };
+    if (databaseUrl.trim()) {
+        envValues.DATABASE_URL = databaseUrl;
+    }
+    else {
+        delete envValues.DATABASE_URL;
+    }
+    if (geminiKey) {
+        envValues.GEMINI_API_KEY = geminiKey;
+    }
+    if (anthropicKey) {
+        envValues.ANTHROPIC_API_KEY = anthropicKey;
+    }
+    const orderedKeys = [
+        'NODE_ENV',
+        'PORT',
+        'DB_TYPE',
+        'DB_LOGGING',
+        'CHECK_PENDING_MIGRATIONS_ON_STARTUP',
+        'DATABASE_URL',
+        'GEMINI_API_KEY',
+        'ANTHROPIC_API_KEY',
+        'JWT_SECRET',
+        'JWT_REFRESH_SECRET',
+    ];
+    const remainingKeys = Object.keys(envValues)
+        .filter((key) => !orderedKeys.includes(key))
+        .sort();
+    return [...orderedKeys, ...remainingKeys]
+        .filter((key) => envValues[key] !== undefined && envValues[key] !== '')
+        .map((key) => `${key}=${envValues[key]}`)
+        .join('\n')
+        .concat('\n');
+}