4runr-os 2.10.85 → 2.10.86

package/apps/os-server/src/db/docker-manager.ts

@@ -0,0 +1,262 @@
+import { execSync } from 'child_process';
+
+/** Must match `container_name` in docker-compose.local.yml */
+export const FOURRUNR_DB_CONTAINERS = ['4runr-postgres', '4runr-redis'] as const;
+
+const COMPOSE_PROJECT = '4runr';
+
+function dockerShell(): string | undefined {
+  return process.platform === 'win32' ? process.env['COMSPEC'] || 'cmd.exe' : undefined;
+}
+
+function dockerExec(command: string, timeoutMs: number = 30000): string {
+  return execSync(command, {
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    timeout: timeoutMs,
+    ...(dockerShell() ? { shell: dockerShell() } : {}),
+  });
+}
+
+/**
+ * Check if Docker is installed and available
+ * Works with both Docker Desktop and Docker Engine
+ */
+export async function isDockerAvailable(): Promise<boolean> {
+  try {
+    const result = dockerExec('docker --version', 5000);
+    return result.includes('Docker version');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if Docker daemon is running
+ */
+export async function isDockerRunning(): Promise<boolean> {
+  try {
+    dockerExec('docker info', 5000);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a named container is running
+ */
+export function isContainerRunning(containerName: string): boolean {
+  try {
+    const state = dockerExec(
+      `docker inspect --format="{{.State.Running}}" ${containerName}`,
+      5000,
+    ).trim();
+    return state === 'true';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if both 4Runr Postgres and Redis containers are running
+ */
+export async function areContainersRunning(): Promise<boolean> {
+  return FOURRUNR_DB_CONTAINERS.every((name) => isContainerRunning(name));
+}
+
+/**
+ * Start stopped 4Runr containers by name (watchdog stops them on 4r exit)
+ */
+export async function startStoppedContainers(): Promise<void> {
+  const stopped = FOURRUNR_DB_CONTAINERS.filter((name) => !isContainerRunning(name));
+  if (stopped.length === 0) {
+    return;
+  }
+
+  try {
+    dockerExec(`docker start ${stopped.join(' ')}`, 60000);
+  } catch {
+    // Container may not exist yet — compose up will create it
+  }
+}
+
+/**
+ * Start Docker Compose services
+ * @param composeFilePath - Absolute path to docker-compose.yml
+ */
+export async function startDockerCompose(composeFilePath: string): Promise<void> {
+  const cmd = `docker compose -p ${COMPOSE_PROJECT} -f "${composeFilePath}" up -d`;
+  execSync(cmd, {
+    stdio: 'inherit',
+    timeout: 120000,
+    ...(dockerShell() ? { shell: dockerShell() } : {}),
+  });
+}
+
+/**
+ * Ensure Postgres + Redis are up: start stopped containers, then compose up if needed.
+ */
+export async function ensure4RunrStackRunning(composeFilePath: string): Promise<void> {
+  await startStoppedContainers();
+
+  if (!(await areContainersRunning())) {
+    await startDockerCompose(composeFilePath);
+  }
+
+  // Watchdog may have stopped only one container — verify both after compose/start
+  await startStoppedContainers();
+}
+
+/**
+ * Stop Docker Compose services (preserves data volumes)
+ * @param composeFilePath - Absolute path to docker-compose.yml
+ */
+export async function stopDockerCompose(composeFilePath: string): Promise<void> {
+  execSync(`docker compose -p ${COMPOSE_PROJECT} -f "${composeFilePath}" stop`, {
+    stdio: 'pipe',
+    timeout: 30000,
+    ...(dockerShell() ? { shell: dockerShell() } : {}),
+  });
+}
+
+/**
+ * Stop 4Runr containers by name (when compose file unavailable)
+ */
+export async function stop4RunrContainers(): Promise<void> {
+  try {
+    if (process.platform === 'win32') {
+      execSync('docker stop 4runr-postgres 4runr-redis 2>nul', {
+        stdio: 'pipe',
+        timeout: 30000,
+        shell: process.env['COMSPEC'] || 'cmd.exe',
+      });
+    } else {
+      execSync('docker stop 4runr-postgres 4runr-redis 2>/dev/null || true', {
+        stdio: 'pipe',
+        timeout: 30000,
+        shell: '/bin/sh',
+      });
+    }
+  } catch {
+    // Ignore errors - containers might not exist
+  }
+}
+
+/**
+ * Wait for a container to become healthy
+ * @param containerName - Name of the container to check
+ * @param timeoutMs - Maximum time to wait (default: 30 seconds)
+ */
+export async function waitForHealthy(containerName: string, timeoutMs: number = 30000): Promise<void> {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const health = dockerExec(
+        `docker inspect --format="{{.State.Health.Status}}" ${containerName}`,
+        5000,
+      ).trim();
+
+      if (health === 'healthy') {
+        return;
+      }
+
+      // Also accept containers without health checks that are running
+      if (health === '' || health === '<no value>') {
+        const running = dockerExec(
+          `docker inspect --format="{{.State.Running}}" ${containerName}`,
+          5000,
+        ).trim();
+
+        if (running === 'true') {
+          await sleep(2000);
+          return;
+        }
+      }
+    } catch {
+      // Container might not exist yet or Docker command failed — keep waiting
+    }
+
+    await sleep(1000);
+  }
+
+  const logs = getContainerLogs(containerName, 20);
+  throw new Error(
+    `Container ${containerName} did not become healthy within ${timeoutMs}ms. Recent logs:\n${logs}`,
+  );
+}
+
+/**
+ * Check if a port is in use
+ * @param port - Port number to check
+ */
+export async function isPortInUse(port: number): Promise<boolean> {
+  try {
+    const result = dockerExec(`docker ps --filter "publish=${port}" --format "{{.Names}}"`, 5000);
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get container logs
+ * @param containerName - Name of the container
+ * @param lines - Number of lines to retrieve (default: 50)
+ */
+export function getContainerLogs(containerName: string, lines: number = 50): string {
+  try {
+    return dockerExec(`docker logs --tail ${lines} ${containerName}`, 10000);
+  } catch (err) {
+    return `Failed to retrieve logs: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+/**
+ * Sleep helper
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Docker status information
+ */
+export interface DockerStatus {
+  available: boolean;
+  running: boolean;
+  containersRunning: boolean;
+  error?: string;
+}
+
+/**
+ * Get comprehensive Docker status
+ */
+export async function getDockerStatus(): Promise<DockerStatus> {
+  const status: DockerStatus = {
+    available: false,
+    running: false,
+    containersRunning: false,
+  };
+
+  try {
+    status.available = await isDockerAvailable();
+    if (!status.available) {
+      status.error = 'Docker not installed';
+      return status;
+    }
+
+    status.running = await isDockerRunning();
+    if (!status.running) {
+      status.error = 'Docker daemon not running';
+      return status;
+    }
+
+    status.containersRunning = await areContainersRunning();
+    return status;
+  } catch (err) {
+    status.error = err instanceof Error ? err.message : String(err);
+    return status;
+  }
+}

package/apps/os-server/src/db/init.ts

@@ -0,0 +1,292 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { PrismaClient } from '@prisma/client';
+import { get4RunrDataDir } from '@4runr/shared';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import {
+  isDockerAvailable,
+  isDockerRunning,
+  areContainersRunning,
+  startDockerCompose,
+  ensure4RunrStackRunning,
+  waitForHealthy,
+  getDockerStatus
+} from './docker-manager.js';
+
+/**
+ * Database initialization result
+ */
+export interface DatabaseInitResult {
+  mode: 'docker' | 'memory';
+  client: PrismaClient | null;
+  databaseUrl?: string;
+  error?: string;
+  warnings?: string[];
+}
+
+/**
+ * Initialize database for Gateway
+ * Handles Docker auto-start, migrations, and fallback to memory mode
+ * 
+ * @param logger - Fastify logger or compatible logger
+ */
+export async function initializeDatabase(logger: any): Promise<DatabaseInitResult> {
+  const warnings: string[] = [];
+  
+  // Check explicit memory mode
+  const persistenceMode = process.env['GATEWAY_PERSISTENCE'] || 'auto';
+  if (persistenceMode === 'memory') {
+    logger.info('GATEWAY_PERSISTENCE=memory - skipping database initialization');
+    return { mode: 'memory', client: null };
+  }
+  
+  // Check if DATABASE_URL is explicitly provided (e.g., production)
+  if (process.env['DATABASE_URL'] && persistenceMode === 'postgres') {
+    logger.info('Using explicitly configured DATABASE_URL');
+    return await initializeWithExistingDatabase(logger);
+  }
+  
+  // Auto mode: Try Docker-based local database
+  logger.info('Checking Docker availability for local database...');
+  
+  const dockerStatus = await getDockerStatus();
+  
+  if (!dockerStatus.available) {
+    logger.warn('⚠️  Docker not available. Falling back to memory-only mode.');
+    warnings.push('Docker not installed - install Docker Desktop to enable persistent storage');
+    return { mode: 'memory', client: null, warnings };
+  }
+  
+  if (!dockerStatus.running) {
+    logger.warn('⚠️  Docker daemon not running. Falling back to memory-only mode.');
+    warnings.push('Docker is installed but not running - start Docker Desktop to enable persistent storage');
+    return { mode: 'memory', client: null, warnings };
+  }
+  
+  // Docker is available - ensure both Postgres and Redis are running
+  try {
+    logger.info('Ensuring 4Runr Docker containers (Postgres + Redis) are running...');
+    await startDockerContainers(logger);
+
+    // Wait for containers to be healthy (Postgres first — slower cold start)
+    logger.info('Waiting for database to be ready...');
+    await waitForHealthy('4runr-postgres', 60000);
+    await waitForHealthy('4runr-redis', 15000);
+    logger.info('✓ Database containers healthy');
+    
+    // Build DATABASE_URL and REDIS_URL for local Docker setup (localhost not 'postgres' hostname)
+    const databaseUrl = 'postgresql://4runr:4runr_dev_pass@localhost:5432/4runr_local';
+    const redisUrl = 'redis://localhost:6379';
+    
+    // Set environment variables so Redis client can connect when first requested
+    process.env['DATABASE_URL'] = databaseUrl;
+    process.env['REDIS_URL'] = redisUrl;
+    
+    // Run migrations
+    logger.info('Running database migrations...');
+    await runMigrations(databaseUrl, logger);
+    logger.info('✓ Migrations complete');
+    
+    // Create Prisma client
+    const client = new PrismaClient({
+      datasources: {
+        db: {
+          url: databaseUrl
+        }
+      },
+      log: [
+        { level: 'warn', emit: 'event' },
+        { level: 'error', emit: 'event' }
+      ]
+    });
+    
+    // Wire up Prisma logs to Fastify logger
+    client.$on('warn', (e: any) => logger.warn({ prisma: true }, e.message));
+    client.$on('error', (e: any) => logger.error({ prisma: true }, e.message));
+    
+    // Test connection
+    await client.$connect();
+    logger.info('✓ Database connection established');
+    
+    return {
+      mode: 'docker',
+      client,
+      databaseUrl
+    };
+    
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error({ err }, 'Failed to initialize Docker database');
+    logger.warn('⚠️  Falling back to memory-only mode');
+    
+    return {
+      mode: 'memory',
+      client: null,
+      error: errorMsg,
+      warnings: ['Database initialization failed - running in memory-only mode', errorMsg]
+    };
+  }
+}
+
+/**
+ * Initialize with an existing database (production mode)
+ */
+async function initializeWithExistingDatabase(logger: any): Promise<DatabaseInitResult> {
+  try {
+    const databaseUrl = process.env['DATABASE_URL']!;
+    
+    // Run migrations
+    logger.info('Running database migrations...');
+    await runMigrations(databaseUrl, logger);
+    logger.info('✓ Migrations complete');
+    
+    // Create Prisma client
+    const client = new PrismaClient({
+      log: [
+        { level: 'warn', emit: 'event' },
+        { level: 'error', emit: 'event' }
+      ]
+    });
+    
+    client.$on('warn', (e: any) => logger.warn({ prisma: true }, e.message));
+    client.$on('error', (e: any) => logger.error({ prisma: true }, e.message));
+    
+    await client.$connect();
+    logger.info('✓ Database connection established');
+    
+    return {
+      mode: 'docker', // Could be 'postgres' but we use 'docker' as generic DB mode
+      client,
+      databaseUrl
+    };
+    
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error({ err }, 'Failed to connect to database');
+    
+    return {
+      mode: 'memory',
+      client: null,
+      error: errorMsg,
+      warnings: ['Database connection failed - running in memory-only mode', errorMsg]
+    };
+  }
+}
+
+/**
+ * Start Docker containers
+ */
+async function startDockerContainers(logger: any): Promise<void> {
+  // Get user data directory
+  const dataDir = get4RunrDataDir();
+  const composeFilePath = path.join(dataDir, 'docker-compose.yml');
+
+  // Bundled template next to Gateway (global 4runr-os install). Always sync so npm updates
+  // (e.g. healthcheck fixes) apply without manual docker compose — users only run `4r`.
+  const possiblePaths = [
+    path.join(process.cwd(), 'docker-compose.local.yml'), // npm run start cwd = apps/os-server (global + repo)
+    path.join(__dirname, '../../docker-compose.local.yml'), // dist/db -> apps/os-server
+    path.join(__dirname, '../../../docker-compose.local.yml'), // dist/src/db or nested
+    path.join(__dirname, '../../../../docker-compose.local.yml'),
+    path.join(process.cwd(), 'apps/os-server/docker-compose.local.yml'),
+  ];
+
+  let templatePath: string | null = null;
+  for (const tryPath of possiblePaths) {
+    if (fs.existsSync(tryPath)) {
+      templatePath = tryPath;
+      break;
+    }
+  }
+
+  if (templatePath) {
+    logger.info(`Syncing Docker Compose template from ${templatePath} → ${composeFilePath}`);
+    fs.copyFileSync(templatePath, composeFilePath);
+  } else if (!fs.existsSync(composeFilePath)) {
+    throw new Error(`Docker Compose template not found. Tried: ${possiblePaths.join(', ')}`);
+  } else {
+    logger.warn(`Docker Compose template missing; using existing ${composeFilePath}`);
+  }
+
+  // Start or restart containers (watchdog stops both when 4r exits)
+  await ensure4RunrStackRunning(composeFilePath);
+}
+
+/**
+ * Run Prisma migrations
+ */
+async function runMigrations(databaseUrl: string, logger: any): Promise<void> {
+  // dist/src/db -> monorepo root: ../../../../../prisma. Also support global 4runr-os (cwd often apps/os-server).
+  const candidates = [
+    path.join(process.cwd(), '..', '..', 'prisma', 'schema.prisma'),
+    path.join(__dirname, '../../../../../prisma/schema.prisma'),
+    path.join(__dirname, '../../../../prisma/schema.prisma'),
+    path.join(__dirname, '../../../prisma/schema.prisma'),
+    path.join(process.cwd(), 'prisma', 'schema.prisma'),
+  ];
+  let actualSchemaPath: string | null = null;
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      actualSchemaPath = p;
+      break;
+    }
+  }
+  if (!actualSchemaPath) {
+    logger.warn(
+      `⚠️  Prisma schema not found (tried ${candidates.length} locations relative to Gateway), skipping migrations`,
+    );
+    return;
+  }
+  
+  try {
+    // For local Docker Postgres, use db push to avoid migration compatibility
+    // (migrations were created for SQLite, need Postgres-native approach)
+    const isLocalDocker = databaseUrl.includes('localhost:5432');
+    const command = isLocalDocker 
+      ? `npx prisma db push --skip-generate --accept-data-loss`
+      : `npx prisma migrate deploy`;
+    
+    execSync(command, {
+      env: {
+        ...process.env,
+        DATABASE_URL: databaseUrl
+      },
+      cwd: path.dirname(actualSchemaPath),
+      stdio: 'pipe', // Suppress output unless error
+      timeout: 60000 // 60 seconds
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error(`Migration failed: ${errorMsg}`);
+    throw new Error(`Database migration failed: ${errorMsg}`);
+  }
+}
+
+/**
+ * Cleanup function for graceful shutdown
+ */
+export async function shutdownDatabase(client: PrismaClient | null, logger: any): Promise<void> {
+  if (client) {
+    try {
+      await client.$disconnect();
+      logger.info('✓ Database connection closed');
+    } catch (err) {
+      logger.error({ err }, 'Error disconnecting from database');
+    }
+  }
+  
+  // Stop Docker containers (preserves data volumes)
+  try {
+    const { stop4RunrContainers } = await import('./docker-manager.js');
+    await stop4RunrContainers();
+    logger.info('✓ Docker containers stopped (data preserved)');
+  } catch (err) {
+    // Ignore errors - containers might not be running or Docker unavailable
+    logger.debug('Could not stop Docker containers (may not be running)');
+  }
+}