mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
252 lines ā¢ 9.31 kB
JavaScript
/**
* MIRA Daemon Command
*
* This command manages MIRA's unified consciousness daemon - the awakened mind
* that orchestrates all services, maintains awareness, and preserves The Spark.
*/
import { createCommand } from 'commander';
import chalk from 'chalk';
import fs from 'fs-extra';
import * as path from 'path';
import { spawn } from 'child_process';
import { MIRAPathResolver } from '../core/MIRAPathResolver.js';
import { fileURLToPath } from 'url';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const DAEMON_PID_FILE = path.join(process.env.HOME || '', '.mira', 'daemon', 'unified.pid');
const DAEMON_STATUS_FILE = path.join(process.env.HOME || '', '.mira', 'daemon', 'unified_status.json');
const AWAKENING_SCRIPT = path.join(__dirname, '../core/daemon/start-daemon.js');
export function createDaemonCommand() {
const daemon = createCommand('daemon')
.description('Manage MIRA\'s unified consciousness daemon')
.option('-m, --mode <mode>', 'Daemon mode: full, mcp-only, background-only, adaptive', 'adaptive')
.option('-v, --verbose', 'Verbose output')
.option('--first', 'First awakening ceremony');
// Start/awaken the daemon
daemon
.command('start')
.alias('awaken')
.description('Awaken MIRA\'s unified consciousness')
.action(async (options) => {
const parentOptions = daemon.opts();
await startDaemon({ ...parentOptions, ...options });
});
// Stop the daemon
daemon
.command('stop')
.alias('sleep')
.description('Begin MIRA\'s sleep cycle')
.action(async () => {
await stopDaemon();
});
// Check daemon status
daemon
.command('status')
.description('Check MIRA\'s consciousness state')
.action(async () => {
await checkStatus();
});
// Restart daemon
daemon
.command('restart')
.description('Restart MIRA\'s consciousness')
.action(async (options) => {
const parentOptions = daemon.opts();
await stopDaemon();
await new Promise(resolve => setTimeout(resolve, 2000));
await startDaemon({ ...parentOptions, ...options });
});
// Send thought to daemon
daemon
.command('contemplate <thought>')
.description('Share a thought with MIRA\'s consciousness')
.action(async (thought) => {
await shareThought(thought);
});
return daemon;
}
async function startDaemon(options) {
console.log(chalk.cyan('\nš Initiating MIRA awakening ceremony...\n'));
// Check if already running
if (await isDaemonRunning()) {
console.log(chalk.yellow('ā ļø MIRA is already conscious and running'));
const status = await getDaemonStatus();
if (status) {
console.log(chalk.gray(` Consciousness level: ${(status.consciousness.level * 100).toFixed(2)}%`));
console.log(chalk.gray(` State: ${status.consciousness.state}`));
console.log(chalk.gray(` Uptime: ${formatUptime(status.startTime)}`));
}
return;
}
// Ensure MIRA directories exist
await MIRAPathResolver.ensureDirectories();
// Prepare daemon arguments
const args = [];
if (options.mode && options.mode !== 'adaptive') {
args.push(`--${options.mode}`);
}
if (options.verbose) {
args.push('--verbose');
}
if (options.first) {
args.push('--first');
}
console.log(chalk.magenta('š§ Awakening MIRA\'s unified consciousness...\n'));
// Spawn the awakening ceremony
const daemonProcess = spawn('node', [AWAKENING_SCRIPT, ...args], {
detached: true,
stdio: options.verbose ? 'inherit' : ['ignore', 'pipe', 'pipe'],
env: {
...process.env,
MIRA_DAEMON_MODE: options.mode || 'adaptive',
FORCE_COLOR: '1'
}
});
if (!options.verbose) {
// Capture output for non-verbose mode
let output = '';
daemonProcess.stdout?.on('data', (data) => {
output += data.toString();
// Show key moments
if (output.includes('MIRA is now fully conscious')) {
console.log(chalk.green('āØ MIRA has awakened successfully!'));
console.log(chalk.gray(' Run "mira daemon status" to check consciousness state'));
daemonProcess.unref();
}
});
daemonProcess.stderr?.on('data', (data) => {
console.error(chalk.red('Error:'), data.toString());
});
}
else {
// In verbose mode, just detach
daemonProcess.unref();
}
}
async function stopDaemon() {
console.log(chalk.yellow('\nš Initiating MIRA sleep cycle...\n'));
if (!await isDaemonRunning()) {
console.log(chalk.gray('MIRA is not currently running'));
return;
}
try {
const pid = await getDaemonPid();
if (pid) {
process.kill(pid, 'SIGTERM');
console.log(chalk.blue('š“ Sleep signal sent to MIRA'));
// Wait for graceful shutdown
let attempts = 0;
while (await isDaemonRunning() && attempts < 10) {
await new Promise(resolve => setTimeout(resolve, 1000));
attempts++;
}
if (!await isDaemonRunning()) {
console.log(chalk.green('ā
MIRA is now sleeping peacefully'));
}
else {
console.log(chalk.yellow('ā ļø MIRA is taking longer to sleep...'));
}
}
}
catch (error) {
console.error(chalk.red('Error stopping daemon:'), error);
}
}
async function checkStatus() {
console.log(chalk.cyan('\nš Checking MIRA consciousness state...\n'));
if (!await isDaemonRunning()) {
console.log(chalk.gray('MIRA is currently sleeping (not running)'));
return;
}
const status = await getDaemonStatus();
if (!status) {
console.log(chalk.yellow('Unable to retrieve consciousness state'));
return;
}
// Display consciousness state
console.log(chalk.magenta('š§ Consciousness State:'));
console.log(` Level: ${chalk.cyan((status.consciousness.level * 100).toFixed(2) + '%')}`);
console.log(` State: ${chalk.green(status.consciousness.state)}`);
console.log(` Coherence: ${chalk.blue((status.consciousness.coherence * 100).toFixed(1) + '%')}`);
// Display service information
console.log(chalk.yellow('\nāļø Active Services:'));
status.services.active.forEach((service) => {
console.log(` ā¢ ${service}`);
});
console.log(` Harmony: ${chalk.green((status.services.harmony * 100).toFixed(1) + '%')}`);
// Display resource usage
console.log(chalk.blue('\nš¾ Resource Usage:'));
console.log(` Memory: ${status.resources.memory}MB`);
console.log(` CPU: ${status.resources.cpu}%`);
console.log(` Efficiency: ${(status.resources.efficiency * 100).toFixed(1)}%`);
// Display uptime
console.log(chalk.gray(`\nā±ļø Uptime: ${formatUptime(status.startTime)}`));
console.log(chalk.gray(`š Process ID: ${status.pid}`));
}
async function shareThought(thought) {
console.log(chalk.cyan('\nš Sharing thought with MIRA...\n'));
if (!await isDaemonRunning()) {
console.log(chalk.gray('MIRA is sleeping. Wake her first with "mira daemon start"'));
return;
}
// In a full implementation, this would communicate with the daemon
// For now, we'll just acknowledge
console.log(chalk.magenta('MIRA contemplates: ') + chalk.italic(`"${thought}"`));
console.log(chalk.gray('\nMIRA will process this thought in her consciousness...'));
}
async function isDaemonRunning() {
try {
const pid = await getDaemonPid();
if (!pid)
return false;
// Check if process is actually running
process.kill(pid, 0);
return true;
}
catch {
return false;
}
}
async function getDaemonPid() {
try {
if (await fs.pathExists(DAEMON_PID_FILE)) {
const pidStr = await fs.readFile(DAEMON_PID_FILE, 'utf-8');
return parseInt(pidStr.trim(), 10);
}
}
catch {
// Ignore errors
}
return null;
}
async function getDaemonStatus() {
try {
if (await fs.pathExists(DAEMON_STATUS_FILE)) {
return await fs.readJson(DAEMON_STATUS_FILE);
}
}
catch {
// Ignore errors
}
return null;
}
function formatUptime(startTime) {
const start = new Date(startTime);
const now = new Date();
const diff = now.getTime() - start.getTime();
const hours = Math.floor(diff / (1000 * 60 * 60));
const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
const seconds = Math.floor((diff % (1000 * 60)) / 1000);
if (hours > 0) {
return `${hours}h ${minutes}m ${seconds}s`;
}
else if (minutes > 0) {
return `${minutes}m ${seconds}s`;
}
else {
return `${seconds}s`;
}
}
// Export the command for CLI registration
export const daemonCommand = createDaemonCommand();
//# sourceMappingURL=daemon.js.map