server.js

/* eslint-disable @typescript-eslint/no-require-imports */
const { loadAppEnv } = require('./server/load-app-env');
loadAppEnv(process.cwd());

const dev = process.env.NODE_ENV !== 'production';
const { assertProductionAuthSecret } = require('./app/lib/security/auth-secret');
assertProductionAuthSecret();

if (typeof globalThis.AsyncLocalStorage === 'undefined') {
  const { AsyncLocalStorage } = require('node:async_hooks');
  globalThis.AsyncLocalStorage = AsyncLocalStorage;
}

// The custom Node server is server-side code, but it imports some Next app
// modules directly for WebSocket runtime handling. Next aliases `server-only`
// during its own bundling; plain Node would otherwise execute the package's
// throwing stub.
const Module = require('module');
const path = require('path');
const originalLoad = Module._load;
const originalResolveFilename = Module._resolveFilename;

function getExportTarget(exportValue) {
  if (typeof exportValue === 'string') {
    return exportValue;
  }
  if (!exportValue || typeof exportValue !== 'object') {
    return null;
  }
  return exportValue.import || exportValue.default || exportValue.require || null;
}

function addEsmOnlyPackageAliases(packageName, aliases) {
  const packageRoot = path.resolve(process.cwd(), 'node_modules', packageName);
  const packageJsonPath = path.join(packageRoot, 'package.json');
  const packageJson = require(packageJsonPath);
  const exportsMap = packageJson.exports && typeof packageJson.exports === 'object'
    ? packageJson.exports
    : { '.': packageJson.main || './dist/index.js' };

  for (const [exportPath, exportValue] of Object.entries(exportsMap)) {
    const target = getExportTarget(exportValue);
    if (!target) {
      continue;
    }
    const request = exportPath === '.'
      ? packageName
      : `${packageName}/${exportPath.replace(/^\.\//, '')}`;
    aliases.set(request, path.resolve(packageRoot, target));
  }
}

const esmOnlyPackageAliases = new Map();
addEsmOnlyPackageAliases('@earendil-works/pi-ai', esmOnlyPackageAliases);
addEsmOnlyPackageAliases('@earendil-works/pi-agent-core', esmOnlyPackageAliases);
addEsmOnlyPackageAliases('@earendil-works/pi-telemetry', esmOnlyPackageAliases);

function resolveEsmOnlyPackageAlias(request, aliases) {
  const exact = aliases.get(request);
  if (exact) return exact;
  for (const [pattern, target] of aliases) {
    const wildcard = pattern.indexOf('*');
    if (wildcard < 0) continue;
    const prefix = pattern.slice(0, wildcard);
    const suffix = pattern.slice(wildcard + 1);
    if (!request.startsWith(prefix) || !request.endsWith(suffix)) continue;
    const subpath = request.slice(prefix.length, request.length - suffix.length);
    // Match public package subpaths, never traversal, encoded separators, or
    // node_modules segments that Node's native exports resolver would reject.
    if (!/^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/.test(subpath)) continue;
    if (subpath.split('/').some((part) => part === '.' || part === '..' || part === 'node_modules')) continue;
    return target.replaceAll('*', subpath);
  }
  return null;
}

Module._resolveFilename = function resolveWithEsmPackageAliases(request, parent, isMain, options) {
  const aliasedPath = resolveEsmOnlyPackageAlias(request, esmOnlyPackageAliases);
  if (aliasedPath) {
    return aliasedPath;
  }
  return originalResolveFilename.call(this, request, parent, isMain, options);
};
Module._load = function loadWithServerOnlyMarker(request, parent, isMain) {
  if (request === 'server-only') {
    return {};
  }
  return originalLoad.call(this, request, parent, isMain);
};

// Apply approved restores in a one-shot process before importing runtime modules,
// so auth caches, schedulers and HTTP cannot observe partly restored state.
require('./server/apply-pending-migration').runPendingMigrationBeforeBoot(process.cwd());

const http = require('http');
const { guardHttpRequestLifecycle } = require('./server/http-request-lifecycle');
const fs = require('fs');
const next = require('next');
const { loadProductionNextConfig } = require('./server/production-next-config');
const { runWithRequestIdentity } = require('./app/lib/security/request-identity');
const { handleHtmlPreviewBoundary } = require('./server/html-preview-boundary');
const { isHtmlPreviewHost } = require('./app/lib/html-preview-origin');
const { handleHttpRequestSafely } = require('./server/http-request-boundary');
const { observeStartupTask } = require('./app/lib/startup/observed-task');
const { postgresFailureCode } = require('./app/lib/db/postgres-diagnostics');
// Terminal service now runs as separate process via Unix Socket
// See server/terminal-service.ts
const {
  resolveSkillsDataDir,
} = require('./app/lib/runtime-data-paths');

const port = parseInt(process.env.PORT || '3000', 10);
const hostname = process.env.HOSTNAME || 'localhost';
const useWebpackDev = dev && process.env.CANVAS_DEV_BUNDLER === 'webpack';
if (dev) {
  console.log(`[Startup] Next.js dev bundler: ${useWebpackDev ? 'webpack' : 'turbopack'}`);
}
const app = next({
  dev,
  hostname,
  port,
  conf: loadProductionNextConfig(dev),
  ...(useWebpackDev ? { webpack: true, turbopack: false } : {}),
});
const handle = app.getRequestHandler();
let authInstance = null;

function getAuth() {
  if (!authInstance) {
    authInstance = require('./app/lib/auth').auth;
  }
  return authInstance;
}

// Helper to get session from Node.js request using better-auth
async function getAuthSession(req) {
  try {
    const auth = getAuth();
    const webHeaders = new Headers();
    for (const [key, value] of Object.entries(req.headers)) {
      if (typeof value === 'string') {
        webHeaders.append(key, value);
      } else if (Array.isArray(value)) {
        for (const v of value) {
          webHeaders.append(key, v);
        }
      }
    }
    return await auth.api.getSession({ headers: webHeaders });
  } catch (e) {
    console.error('[Auth] Error verifying session:', e);
    return null;
  }
}

const DATA = process.env.DATA || path.resolve(process.cwd(), 'data');
const MEDIA_ROOT = path.join(DATA, 'workspace');
const MEDIA_TYPES = {
  pdf: 'application/pdf',
  png: 'image/png',
  jpg: 'image/jpeg',
  jpeg: 'image/jpeg',
  gif: 'image/gif',
  webp: 'image/webp',
  svg: 'image/svg+xml',
  mp4: 'video/mp4',
  webm: 'video/webm',
  ogv: 'video/ogg',
  mov: 'video/quicktime',
  wav: 'audio/wav',
  mp3: 'audio/mpeg',
  m4a: 'audio/mp4',
  aac: 'audio/aac',
  ogg: 'audio/ogg',
  opus: 'audio/opus',
  flac: 'audio/flac',
};

function setNoIndexHeader(res) {
  res.setHeader('X-Robots-Tag', 'noindex, nofollow, noarchive, nosnippet, noimageindex, notranslate');
}

function resolveMediaPath(requestPath) {
  const basePath = path.resolve(MEDIA_ROOT);
  const normalized = path.resolve(basePath, requestPath);
  if (normalized === basePath || normalized.startsWith(`${basePath}${path.sep}`)) {
    return normalized;
  }
  return null;
}

function getContentType(filePath) {
  const ext = path.extname(filePath).slice(1).toLowerCase();
  return MEDIA_TYPES[ext] || 'application/octet-stream';
}

const RETIRED_SEED_SKILLS = [
  {
    name: 'browser-tools',
    marker: 'author: canvas-studios',
  },
];

function cleanupRetiredSeedSkills(skillsDir) {
  for (const skill of RETIRED_SEED_SKILLS) {
    const skillDir = path.join(skillsDir, skill.name);
    const skillMdPath = path.join(skillDir, 'SKILL.md');

    if (!fs.existsSync(skillMdPath)) {
      continue;
    }

    const skillMd = fs.readFileSync(skillMdPath, 'utf8');
    if (!skillMd.includes(`name: ${skill.name}`) || !skillMd.includes(skill.marker)) {
      console.warn(`[Startup] Retired seed skill "${skill.name}" exists but did not match Canvas seed markers; preserving it.`);
      continue;
    }

    fs.rmSync(skillDir, { recursive: true, force: true });
    console.log(`[Startup] Removed retired seed skill: ${skill.name}`);
  }
}

function syncSeedSkills(repoSkillsDir, skillsDir) {
  const copyOptions = {
    recursive: true,
    force: true,
    verbatimSymlinks: true,
  };
  const skillsRoot = path.resolve(skillsDir);
  const maxAttempts = 5;

  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
    try {
      fs.cpSync(repoSkillsDir, skillsDir, copyOptions);
      return;
    } catch (error) {
      const targetPath = typeof error?.path === 'string' ? path.resolve(error.path) : null;
      const canRetry =
        error?.code === 'EEXIST' &&
        targetPath &&
        targetPath !== skillsRoot &&
        targetPath.startsWith(`${skillsRoot}${path.sep}`);

      if (!canRetry || attempt === maxAttempts) {
        throw error;
      }

      console.warn(`[Startup] Replacing existing seed skill path before retry: ${targetPath}`);
      fs.rmSync(targetPath, { recursive: true, force: true });
    }
  }
}

function ensureSkillsDirectory() {
  const skillsDir = resolveSkillsDataDir(process.cwd());
  const repoSkillsDir = path.resolve(process.cwd(), 'seed_skills');

  try {
    if (!fs.existsSync(skillsDir)) {
      fs.mkdirSync(skillsDir, { recursive: true });
      console.log(`[Startup] Created skills directory: ${skillsDir}`);
    }
    if (fs.existsSync(repoSkillsDir)) {
      syncSeedSkills(repoSkillsDir, skillsDir);
      console.log(`[Startup] Synced seed skills to ${skillsDir}`);
    }
    cleanupRetiredSeedSkills(skillsDir);
  } catch (error) {
    console.error('[Startup] Failed to sync skills directory:', error);
  }
}

function ensureRuntimeDirectories() {
  try {
    fs.mkdirSync(path.resolve(MEDIA_ROOT), { recursive: true });
    console.log(`[Startup] Ensured workspace directory exists: ${MEDIA_ROOT}`);
  } catch (error) {
    console.error(`[Startup] Failed to create WORKSPACE_DIR at ${MEDIA_ROOT}:`, error);
    throw error;
  }

  try {
    fs.mkdirSync(DATA, { recursive: true });
    console.log(`[Startup] Ensured data directory exists: ${DATA}`);
  } catch (error) {
    console.error(`[Startup] Failed to create data directory at ${DATA}:`, error);
    throw error;
  }

  // Ensure secrets directory exists for Canvas-Integrations.env
  const secretsDir = path.join(DATA, 'secrets');
  try {
    fs.mkdirSync(secretsDir, { recursive: true });
    console.log(`[Startup] Ensured secrets directory exists: ${secretsDir}`);
  } catch (error) {
    console.error(`[Startup] Failed to create secrets directory at ${secretsDir}:`, error);
    throw error;
  }
}

function serveMedia(req, res) {
  setNoIndexHeader(res);

  if (req.method !== 'GET' && req.method !== 'HEAD') {
    res.statusCode = 405;
    res.setHeader('Allow', 'GET, HEAD');
    res.end();
    return;
  }

  const url = new URL(req.url, 'http://localhost');
  const rawPath = url.pathname.replace(/^\/media\/?/, '');
  if (!rawPath) {
    res.statusCode = 404;
    res.end('Not found');
    return;
  }

  let decodedPath;
  try {
    decodedPath = decodeURIComponent(rawPath);
  } catch {
    res.statusCode = 400;
    res.end('Bad request');
    return;
  }

  const filePath = resolveMediaPath(decodedPath);
  console.log(`[Media Debug] Request: ${decodedPath} -> Resolved: ${filePath} | MEDIA_ROOT: ${MEDIA_ROOT} | DATA: ${DATA}`);
  if (!filePath) {
    console.log(`[Media Debug] Forbidden: Path resolved to null`);
    res.statusCode = 403;
    res.end('Forbidden');
    return;
  }

  fs.stat(filePath, (statErr, stats) => {
    if (statErr || !stats.isFile()) {
      console.log(`[Media Debug] 404: File not found at ${filePath} | Error: ${statErr?.message || 'Not a file'}`);
      res.statusCode = 404;
      res.end('Not found');
      return;
    }

    const totalSize = stats.size;
    const range = req.headers.range;
    const contentType = getContentType(filePath);
    const ext = path.extname(filePath).slice(1).toLowerCase();
    const isImage = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'].includes(ext);
    const isMedia = ['mp4', 'webm', 'ogv', 'mov', 'wav', 'mp3', 'm4a', 'aac', 'ogg', 'opus', 'flac'].includes(ext);
    const cacheControl = isImage
      ? 'private, max-age=300'
      : isMedia
        ? 'private, max-age=60'
        : 'no-store, max-age=0';

    res.setHeader('Content-Type', contentType);
    res.setHeader('Content-Disposition', `inline; filename="${path.basename(filePath)}"`);
    res.setHeader('Accept-Ranges', 'bytes');
    res.setHeader('Cache-Control', cacheControl);
    res.setHeader('X-Accel-Buffering', 'no');

    if (!range) {
      res.statusCode = 200;
      res.setHeader('Content-Length', totalSize);
      if (req.method === 'HEAD') {
        res.end();
        return;
      }
      const stream = fs.createReadStream(filePath, { highWaterMark: 1024 * 1024 });
      stream.on('error', () => {
        res.destroy();
      });
      stream.pipe(res);
      return;
    }

    const match = /bytes=(\d*)-(\d*)/i.exec(range);
    let start = 0;
    let end = totalSize - 1;
    if (match) {
      if (match[1]) start = Number(match[1]);
      if (match[2]) end = Number(match[2]);
      if (!match[1] && match[2]) {
        const suffixLength = Number(match[2]);
        if (Number.isFinite(suffixLength)) {
          start = Math.max(totalSize - suffixLength, 0);
          end = totalSize - 1;
        }
      }
    }

    if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= totalSize) {
      res.statusCode = 416;
      res.setHeader('Content-Range', `bytes */${totalSize}`);
      res.end();
      return;
    }

    end = Math.min(end, totalSize - 1);
    res.statusCode = 206;
    res.setHeader('Content-Range', `bytes ${start}-${end}/${totalSize}`);
    res.setHeader('Content-Length', end - start + 1);
    if (req.method === 'HEAD') {
      res.end();
      return;
    }
    const stream = fs.createReadStream(filePath, {
      start,
      end,
      highWaterMark: 1024 * 1024,
    });
    stream.on('error', () => {
      res.destroy();
    });
    stream.pipe(res);
  });
}

async function runStartupDatabaseMigrations() {
  if (process.env.CANVAS_DATABASE_MIGRATIONS_COMPLETED === 'true') {
    console.log('[Startup] Database migrations already completed by the container entrypoint');
    return;
  }
  const { runStartupDatabaseMigrations: migrateDatabase } = require('./app/lib/db/startup-migrations');
  await migrateDatabase();
  // Runtime modules can be loaded later by Next.js on demand. They must not
  // reopen the schema migration path while requests are already being served.
  process.env.CANVAS_DATABASE_MIGRATIONS_COMPLETED = 'true';
}

// Ensure all runtime directories and tokens are set up before starting the server
console.log('[Startup] Starting runtime setup...');

try {
  console.log('[Startup] Calling ensureRuntimeDirectories()...');
  ensureRuntimeDirectories();
  console.log('[Startup] ensureRuntimeDirectories() completed');
} catch (error) {
  console.error('[Startup] CRITICAL ERROR in ensureRuntimeDirectories():', error.message);
  console.error('[Startup] Stack trace:', error.stack);
  // Continue anyway - don't block server startup
}

try {
  console.log('[Startup] Calling ensureSkillsDirectory()...');
  ensureSkillsDirectory();
  console.log('[Startup] ensureSkillsDirectory() completed');
} catch (error) {
  console.error('[Startup] ERROR in ensureSkillsDirectory():', error.message);
  console.error('[Startup] Stack trace:', error.stack);
}

console.log('[Startup] Runtime setup complete');

function runOrphanedAssetsCleanup() {
  try {
    console.log('[Startup] Running orphaned-assets cleanup...');
    const { cleanupOrphanedStudioAssets } = require('./app/lib/cleanup/orphaned-assets');
    cleanupOrphanedStudioAssets().then((result) => {
      console.log(`[Startup] Orphaned-assets cleanup: ${result.deleted} files deleted, ${result.errors.length} errors`);
    }).catch((err) => {
      console.warn('[Startup] Orphaned-assets cleanup failed:', err.message);
    });
  } catch (err) {
    console.warn('[Startup] Orphaned-assets cleanup could not be loaded:', err.message);
  }
}

function runStudioPresetSeeding() {
  try {
    console.log('[Startup] Seeding studio preset assets...');
    const { ensureDefaultStudioPresetsSeeded } = require('./app/lib/integrations/studio-preset-defaults');
    const { ensureStudioAssetsWorkspace } = require('./app/lib/integrations/studio-workspace');
    ensureStudioAssetsWorkspace().then(() => {
      return ensureDefaultStudioPresetsSeeded();
    }).then((result) => {
      console.log(`[Startup] Studio preset seeding: ${result.total} presets (${result.inserted} inserted, ${result.updated} updated)`);
    }).catch((err) => {
      console.warn('[Startup] Studio preset seeding failed:', err.message);
    });
  } catch (err) {
    console.warn('[Startup] Studio preset seeding could not be loaded:', err.message);
  }
}

function scheduleExpiredSessionCleanup() {
  try {
    const { openDb, getDatabaseProvider } = require('./app/lib/db/index');
    const isPostgres = getDatabaseProvider() === 'postgres';
    const CLEANUP_INTERVAL_MS = 15 * 60 * 1000;
    // Current pgTimestamp values are epoch milliseconds; older installations
    // can still contain epoch seconds. Preserve valid sessions in either unit.
    const cleanupQuery = isPostgres
      ? `DELETE FROM session WHERE
          (expires_at < 100000000000 AND expires_at < floor(extract(epoch from now()))::bigint)
          OR (expires_at >= 100000000000 AND expires_at < floor(extract(epoch from now()) * 1000)::bigint)`
      : "DELETE FROM session WHERE expires_at < unixepoch()";
    let cleanupInFlight = false;
    async function purgeExpiredSessions() {
      if (cleanupInFlight) return;
      cleanupInFlight = true;
      try {
        const dbConn = await openDb();
        try {
          const result = await dbConn.run(cleanupQuery);
          if (result.changes > 0) {
            console.log(`[Session Cleanup] Deleted ${result.changes} expired session(s)`);
          }
          if (!isPostgres) {
            await dbConn.run("PRAGMA optimize");
          }
        } finally {
          await dbConn.close();
        }
      } catch {
        console.warn('[Session Cleanup] Failed; the next scheduled run will retry.');
      } finally {
        cleanupInFlight = false;
      }
    }
    purgeExpiredSessions();
    setInterval(purgeExpiredSessions, CLEANUP_INTERVAL_MS).unref?.();
    console.log('[Startup] Expired session cleanup scheduled (every 15min)');
  } catch (err) {
    console.warn('[Startup] Session cleanup could not be initialized:', err.message);
  }
}

function scheduleBackgroundMaintenance() {
  const timer = setTimeout(() => {
    console.log('[Startup] Starting background maintenance...');
    runOrphanedAssetsCleanup();
    runStudioPresetSeeding();
    scheduleExpiredSessionCleanup();
    import('./app/lib/license/refresh.ts')
      .then((refreshModule) => {
        resolveImportedServerModule(
          refreshModule,
          ['initializeCommunityLicenseRefreshRuntime'],
          'Community license refresh',
        ).initializeCommunityLicenseRefreshRuntime();
      })
      .catch((err) => {
        console.warn('[Startup] Community license refresh could not be initialized:', err.message);
      });
    import('./app/lib/license/managed-team-sync.ts')
      .then((managedModule) => {
        resolveImportedServerModule(
          managedModule,
          ['initializeManagedTeamSyncRuntime'],
          'Managed team sync',
        ).initializeManagedTeamSyncRuntime();
      })
      .catch((err) => {
        console.warn('[Startup] Managed team sync could not be initialized:', err.message);
      });
    import('./app/lib/license/team-license-lifecycle.ts')
      .then((lifecycleModule) => {
        resolveImportedServerModule(
          lifecycleModule,
          ['initializeTeamLicenseLifecycleRuntime'],
          'Team license lifecycle',
        ).initializeTeamLicenseLifecycleRuntime();
      })
      .catch((err) => {
        console.warn('[Startup] Team license lifecycle could not be initialized:', err.message);
      });
    import('./app/lib/memory/review-worker.ts')
      .then((memoryReviewModule) => {
        resolveImportedServerModule(
          memoryReviewModule,
          ['initializeMemoryReviewWorkerRuntime'],
          'Memory review worker',
        ).initializeMemoryReviewWorkerRuntime();
      })
      .catch((err) => {
        console.warn('[Startup] Memory review worker could not be initialized:', err.message);
      });
    import('./app/lib/email/classification/runtime.ts')
      .then((classificationModule) => {
        resolveImportedServerModule(
          classificationModule,
          ['initializeEmailClassificationRuntime'],
          'Email classification',
        ).initializeEmailClassificationRuntime();
      })
      .catch(() => {
        console.warn('[Startup] Email classification runtime could not be initialized.');
      });
  }, 1500);
  timer.unref?.();
  console.log('[Startup] Background maintenance scheduled');
}

function recoverStaleAutomationRuns() {
  try {
    console.log('[Startup] Running automation stale-run recovery...');
    const { markStaleAutomationRunsFailed } = require('./app/lib/automations/store');
    markStaleAutomationRunsFailed().then((count) => {
      if (count > 0) {
        console.log(`[Startup] Recovered ${count} stale automation run(s)`);
      } else {
        console.log('[Startup] No stale automation runs to recover');
      }
    }).catch((err) => {
      console.warn('[Startup] Failed to recover stale automation runs:', err.message);
    });
  } catch (err) {
    console.warn('[Startup] Could not load automation recovery module:', err.message);
  }
}

async function routeHttpRequest(req, res) {
  if (handleHtmlPreviewBoundary(req, res)) return;
  const url = new URL(req.url, 'http://localhost');

  if (url.pathname.startsWith('/media/')) {
    getAuthSession(req)
      .then((sessionData) => {
        if (!sessionData || !sessionData.user) {
          res.statusCode = 401;
          res.setHeader('Content-Type', 'application/json');
          setNoIndexHeader(res);
          res.end(JSON.stringify({ success: false, error: 'Unauthorized' }));
          return;
        }
        serveMedia(req, res);
      })
      .catch(() => {
        res.statusCode = 401;
        res.setHeader('Content-Type', 'application/json');
        setNoIndexHeader(res);
        res.end(JSON.stringify({ success: false, error: 'Unauthorized' }));
      });
    return;
  }

  // Terminal kill endpoint is now handled by Next.js API routes
  // See app/api/terminal/kill/route.ts

  await handle(req, res);
}

const server = http.createServer((req, res) => {
  guardHttpRequestLifecycle(req, res);
  handleHttpRequestSafely(req, res, () => runWithRequestIdentity(req, () => routeHttpRequest(req, res)));
});
server.prependListener('upgrade', (request, socket) => {
  if (isHtmlPreviewHost(request.headers.host)) {
    delete request.headers.cookie;
    delete request.headers.authorization;
    socket.destroy();
  }
});

let shutdownInProgress = false;
let flushCollaborationDocuments = async () => {};
let flushExcalidrawCollaborationDocuments = async () => {};
let closeChatWebSocketServer = async () => {};
let closeLiveEventsServer = async () => {};
let closeMcpServers = async () => {};

function exitCodeForSignal(signal) {
  if (signal === 'SIGINT') return 130;
  if (signal === 'SIGTERM') return 143;
  return 0;
}

async function shutdownServer(signal) {
  if (shutdownInProgress) {
    return;
  }
  shutdownInProgress = true;

  console.log(`[Startup] Received ${signal}; closing HTTP server...`);
  const forceExitTimer = setTimeout(() => {
    console.warn(`[Startup] Forced exit after ${signal}; HTTP server did not close in time`);
    process.exit(exitCodeForSignal(signal));
  }, 10_000);
  forceExitTimer.unref?.();

  const results = await Promise.allSettled([
    flushCollaborationDocuments,
    flushExcalidrawCollaborationDocuments,
    closeChatWebSocketServer,
    closeLiveEventsServer,
    closeMcpServers,
  ].map((cleanup) => Promise.resolve().then(cleanup)));
  for (const result of results) {
    if (result.status === 'rejected') {
      console.error('[Startup] Error while closing server resources:', result.reason);
    }
  }
  server.close((error) => {
    if (error) {
      console.error(`[Startup] Error while closing HTTP server after ${signal}:`, error);
      process.exit(1);
    }
    console.log(`[Startup] HTTP server closed after ${signal}`);
    process.exit(exitCodeForSignal(signal));
  });
}

process.on('SIGTERM', () => shutdownServer('SIGTERM'));
process.on('SIGINT', () => shutdownServer('SIGINT'));
process.on('uncaughtException', (error) => {
  console.error('[Startup] Uncaught exception:', error);
  process.exit(1);
});
process.on('unhandledRejection', (reason) => {
  console.error('[Startup] Unhandled rejection:', reason);
  process.exit(1);
});

// Register the chat WebSocket handler before Next attaches its own upgrade
// listeners. After app.prepare() we wrap Next's listeners so they never see
// /ws/chat sockets; otherwise Next can still corrupt or close the upgraded
// connection after our ws server has accepted it.
let isCanvasWebSocketRequest = () => false;

function guardNonChatUpgradeListener(listener) {
  if (typeof listener !== 'function' || listener.__canvasUpgradeGuarded) {
    return listener;
  }

  const guardedListener = function guardedUpgradeListener(request, socket, head) {
    if (isCanvasWebSocketRequest(request.url)) {
      return;
    }

    return listener.call(this, request, socket, head);
  };
  guardedListener.__canvasUpgradeGuarded = true;
  guardedListener.__canvasOriginalListener = listener;
  return guardedListener;
}

function installChatUpgradeGuard(targetServer) {
  const originalOn = targetServer.on.bind(targetServer);
  const originalAddListener = targetServer.addListener.bind(targetServer);
  const originalPrependListener = targetServer.prependListener.bind(targetServer);
  const originalOnce = targetServer.once.bind(targetServer);
  const originalPrependOnceListener = targetServer.prependOnceListener.bind(targetServer);

  targetServer.on = function guardedOn(eventName, listener) {
    return originalOn(eventName, eventName === 'upgrade' ? guardNonChatUpgradeListener(listener) : listener);
  };
  targetServer.addListener = function guardedAddListener(eventName, listener) {
    return originalAddListener(eventName, eventName === 'upgrade' ? guardNonChatUpgradeListener(listener) : listener);
  };
  targetServer.prependListener = function guardedPrependListener(eventName, listener) {
    return originalPrependListener(eventName, eventName === 'upgrade' ? guardNonChatUpgradeListener(listener) : listener);
  };
  targetServer.once = function guardedOnce(eventName, listener) {
    return originalOnce(eventName, eventName === 'upgrade' ? guardNonChatUpgradeListener(listener) : listener);
  };
  targetServer.prependOnceListener = function guardedPrependOnceListener(eventName, listener) {
    return originalPrependOnceListener(eventName, eventName === 'upgrade' ? guardNonChatUpgradeListener(listener) : listener);
  };
}

function resolveImportedServerModule(importedModule, requiredFunctions, label) {
  const candidates = [
    importedModule,
    importedModule?.default,
    importedModule?.['module.exports'],
  ];
  const resolved = candidates.find((candidate) => (
    candidate
    && requiredFunctions.every((name) => typeof candidate[name] === 'function')
  ));
  if (!resolved) {
    throw new Error(`${label} module did not expose expected functions`);
  }
  return resolved;
}

async function startServer() {
  try {
    await runStartupDatabaseMigrations();
  } catch (error) {
    console.error('[Startup] CRITICAL ERROR in database migrations:', error.message);
    console.error('[Startup] Stack trace:', error.stack);
    throw error;
  }

  try {
    // Auth is required even when Direct MCP is disabled. Finish its resource
    // seeding before the separate MCP schema/JWKS queries acquire connections.
    const { ensureAuthReady } = require('./app/lib/auth');
    await ensureAuthReady();
    console.log('[Startup] Authentication initialization completed');
  } catch (error) {
    console.error('[Startup] CRITICAL ERROR in authentication initialization');
    throw error;
  }

  try {
    const { assertDirectMcpStartupReady } = require('./app/lib/mcp/server/readiness');
    await assertDirectMcpStartupReady();
    console.log('[Startup] Direct MCP readiness check completed');
  } catch (error) {
    console.error('[Startup] CRITICAL ERROR in Direct MCP readiness:', error.message);
    throw error;
  }

  const mcpManager = require('./app/lib/mcp/manager.ts');
  closeMcpServers = mcpManager.closeAllMcpServers;
  mcpManager.registerMcpShutdownCoordinator(shutdownServer);

  let waitForAgentRuntimeWarmup = null;
  let waitForManagedCatalogWarmup = null;

  console.log('[Startup] Initializing WebSocket Server...');
  try {
    const websocketModule = await import('./server/websocket-server.ts');
    const websocketServer = resolveImportedServerModule(
      websocketModule,
      ['createWebSocketServer', 'isChatWebSocketRequest'],
      'WebSocket server',
    );
    const chatWebSocketServer = websocketServer.createWebSocketServer(server);
    closeChatWebSocketServer = () => websocketServer.closeWebSocketServer(chatWebSocketServer);
    console.log('[Startup] WebSocket Server ready on ws://localhost:' + port + '/ws/chat');
    const browserViewModule = await import('./server/browser-view-server.ts');
    const browserViewServer = resolveImportedServerModule(
      browserViewModule,
      ['createBrowserViewServer', 'isBrowserViewWebSocketRequest'],
      'Browser view server',
    );
    browserViewServer.createBrowserViewServer(server);
    console.log('[Startup] Browser View WebSocket ready on ws://localhost:' + port + '/ws/browser');
    // Keep the custom server and Next server externals on the CommonJS Yjs
    // entry so the long-lived Node process has exactly one constructor set.
    const collaborationModule = require('./server/collaboration-server.ts');
    const collaborationOwnerTestModule = require('./app/lib/collaboration/room-owner-local-test.ts');
    const collaborationOwnerModule = require('./app/lib/collaboration/room-owner-options.ts');
    const roomOwner = collaborationOwnerTestModule.resolveLocalCollaborationRoomOwnerOptions()
      || collaborationOwnerModule.createCollaborationRoomOwnerOptions();
    collaborationModule.createCollaborationServer(server, roomOwner ? { roomOwner } : {});
    flushCollaborationDocuments = collaborationModule.flushCollaborationDocuments;
    const fileActionWorkerModule = require('./app/lib/files/workspace-operation-batch-worker.ts');
    const fileActionWorker = fileActionWorkerModule.initializeWorkspaceOperationBatchWorkerRuntime();
    server.once('close', fileActionWorker.stop);
    const fileCheckWorkerModule = require('./app/lib/files/workspace-operation-check-worker.ts');
    const fileCheckWorker = fileCheckWorkerModule.initializeWorkspaceOperationCheckWorkerRuntime();
    server.once('close', fileCheckWorker.stop);
    const excalidrawCollaborationModule = require('./server/excalidraw-collaboration/server.ts');
    excalidrawCollaborationModule.createExcalidrawCollaborationServer(server);
    flushExcalidrawCollaborationDocuments = excalidrawCollaborationModule.flushExcalidrawCollaborationDocuments;
    const liveEventsModule = require('./server/live-events-server.ts');
    const liveEventsServer = liveEventsModule.createLiveEventsServer(server);
    closeLiveEventsServer = liveEventsServer.close;
    isCanvasWebSocketRequest = (requestUrl) => (
      liveEventsModule.isLiveEventsWebSocketRequest(requestUrl)
      || websocketServer.isChatWebSocketRequest(requestUrl)
      || browserViewServer.isBrowserViewWebSocketRequest(requestUrl)
      || collaborationModule.isCollaborationWebSocketRequest(requestUrl)
      || excalidrawCollaborationModule.isExcalidrawCollaborationWebSocketRequest(requestUrl)
    );
    console.log('[Startup] Collaboration WebSocket ready on ws://localhost:' + port + '/ws/collaboration');
    console.log('[Startup] Excalidraw Collaboration WebSocket ready on ws://localhost:' + port + '/ws/collaboration/excalidraw');
    const agentRuntimeLoaderModule = await import('./server/agent-runtime-loader.ts');
    const agentRuntimeLoader = resolveImportedServerModule(
      agentRuntimeLoaderModule,
      ['preloadAgentRuntimeModules'],
      'Agent runtime loader',
    );
    const { preloadAgentRuntimeModules } = agentRuntimeLoader;
    waitForAgentRuntimeWarmup = observeStartupTask(preloadAgentRuntimeModules().then((result) => {
      console.log('[Startup] Agent runtime modules preloaded', result);
      return result;
    }));
    const managedCatalogModule = await import('./app/lib/managed/control-plane-models.ts');
    const managedCatalog = resolveImportedServerModule(
      managedCatalogModule,
      ['primeCanvasControlPlaneCatalog'],
      'Managed Control Plane catalog',
    );
    const { primeCanvasControlPlaneCatalog } = managedCatalog;
    waitForManagedCatalogWarmup = observeStartupTask(primeCanvasControlPlaneCatalog().then((catalog) => {
      console.log('[Startup] Managed model catalog warmup finished', {
        status: catalog.status,
        errorCode: catalog.errorCode,
        modelCount: catalog.models.length,
      });
      return catalog;
    }));
  } catch (error) {
    console.error('[Startup] ERROR initializing WebSocket Server:', error.message);
    console.error('[Startup] Stack trace:', error.stack);
    isCanvasWebSocketRequest = () => false;
    if (process.env.CANVAS_ALLOW_HTTP_WITHOUT_CHAT_WS !== 'true') {
      throw error;
    }
  }

  installChatUpgradeGuard(server);

  // Channel Manager start (Telegram polling etc.)
  try {
    const { getChannelManager } = require('./app/lib/channels/manager.ts');
    const manager = getChannelManager();
    await manager.start();
    console.log('[Startup] Channel Manager started');
  } catch (error) {
    console.error('[Startup] Channel Manager failed:', error.message);
  }

  console.log('[Startup] Preparing Next.js app...');
  await Promise.all([
    app.prepare(),
    waitForAgentRuntimeWarmup?.(),
    waitForManagedCatalogWarmup?.(),
  ]);
  console.log('[Startup] Next.js app prepared');

  server.listen(port, hostname, (err) => {
    if (err) throw err;
    console.log(`> Ready on http://localhost:${port}`);
    scheduleBackgroundMaintenance();
    recoverStaleAutomationRuns();
  });
}

startServer().catch((error) => {
    // Phase-specific logs above identify the failing gate. A wrapped DB error
    // here may contain SQL parameters or credentials; emit only a safe code.
    console.error('Failed to start server', { errorCode: postgresFailureCode(error) });
    process.exit(1);
});