prismalens 0.5.0-rc.2 → 0.5.0

package/README.md

@@ -12,12 +12,11 @@ npm install -g prismalens
 
 ## Quick start
 
-Check the environment, then start the web interface or run an investigation directly:
+Check the environment, then start the web interface:
 
 ```bash
 prismalens doctor
 pl up
-pl investigate --repo . --query "checkout latency spike after 14:00 UTC"
 ```
 
 ## Commands
@@ -25,14 +24,7 @@ pl investigate --repo . --query "checkout latency spike after 14:00 UTC"
 | Command | Description |
 | --- | --- |
 | `up` | Run PrismaLens as a single process serving the API and web dashboard. |
-| `investigate` | Run a root-cause investigation on a firing alert or query. |
-| `listen` | Start a local HTTP webhook receiver for incoming Alertmanager alerts. |
-| `serve` | Run the JSON-RPC server over stdio for desktop and API integrations. |
-| `doctor` | Preflight-check the environment for harness binaries and credentials. |
-| `init` | Scaffold a default configuration file in the current directory. |
-| `status` | List recent investigation runs and their execution states. |
-| `report` | Display the stored investigation report for a specific run ID. |
-| `auth` | Manage stored credentials for model providers. |
+| `doctor` | Preflight-check the environment: a harness binary on PATH, and its ACP handshake (answers ACP, sign in needed, no answer in 10s, or failed to start). |
 
 ## Documentation
 

package/dist/bin/prismalens.js

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
-import {
-  cliVersion
-} from "../chunk-HPE5CTO4.js";
 
 // bin/prismalens.ts
 import { defineCommand, runMain, showUsage } from "citty";
 import consola from "consola";
+
+// src/version.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function cliVersion() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 4; i++) {
+    try {
+      const pkg = JSON.parse(
+        readFileSync(join(dir, "package.json"), "utf8")
+      );
+      if (pkg.name === "prismalens" && pkg.version) return pkg.version;
+    } catch {
+    }
+    dir = dirname(dir);
+  }
+  return "0.0.0";
+}
+
+// bin/prismalens.ts
 globalThis.AI_SDK_LOG_WARNINGS = false;
 var originalEmit = process.emit;
 process.emit = ((name, ...args) => {
@@ -22,18 +40,11 @@ var main = defineCommand({
   meta: {
     name: "prismalens",
     version: cliVersion(),
-    description: "PrismaLens investigation engine CLI \u2014 drives the two-tier engine (ADR-0008/0010)."
+    description: "Run and check a PrismaLens install"
   },
   subCommands: {
     up: lazy("up"),
-    investigate: lazy("investigate"),
-    listen: lazy("listen"),
-    serve: lazy("serve"),
-    doctor: lazy("doctor"),
-    init: lazy("init"),
-    status: lazy("status"),
-    report: lazy("report"),
-    auth: lazy("auth")
+    doctor: lazy("doctor")
   }
 });
 runMain(main, {

package/dist/chunk-HKIFAYVZ.js

@@ -0,0 +1,53 @@
+// src/cli/up-console.ts
+import { join } from "node:path";
+var DEFAULT_LOG_DIR = "logs";
+function resolveConsoleMode(env, verboseFlag) {
+  if (verboseFlag) return "verbose";
+  return env.PRISMALENS_LOG_CONSOLE === "verbose" ? "verbose" : "quiet";
+}
+function resolveLogDir(env, workspaceDir) {
+  return env.PRISMALENS_LOG_FILE_LOCATION || join(workspaceDir, DEFAULT_LOG_DIR);
+}
+function resolveBind(env) {
+  const port = Number(env.PRISMALENS_PORT) || 3001;
+  const host = env.PRISMALENS_HOST || "127.0.0.1";
+  const protocol = env.PRISMALENS_PROTOCOL === "https" ? "https" : "http";
+  return { host, port, protocol };
+}
+var isWildcard = (host) => host === "0.0.0.0" || host === "::";
+var urlHost = (host) => host.includes(":") ? `[${host}]` : host;
+function displayUrl(bind) {
+  const shown = isWildcard(bind.host) || bind.host === "127.0.0.1" ? "localhost" : urlHost(bind.host);
+  return `${bind.protocol}://${shown}:${bind.port}`;
+}
+function healthUrl(bind) {
+  const host = isWildcard(bind.host) ? "127.0.0.1" : urlHost(bind.host);
+  return `${bind.protocol}://${host}:${bind.port}/health`;
+}
+async function waitForReady(healthUrl2, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 6e4;
+  const intervalMs = opts.intervalMs ?? 250;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetchImpl(healthUrl2, {
+        signal: AbortSignal.timeout(intervalMs * 4)
+      });
+      if (res.status === 200) return true;
+    } catch {
+    }
+    await sleep(intervalMs);
+  }
+  return false;
+}
+
+export {
+  resolveConsoleMode,
+  resolveLogDir,
+  resolveBind,
+  displayUrl,
+  healthUrl,
+  waitForReady
+};

package/dist/src/cli/doctor.js

@@ -1,160 +1,203 @@
-import {
-  loadConfig
-} from "../../chunk-VI32U36Y.js";
-import {
-  resolveBaseDir
-} from "../../chunk-TSW5RW5B.js";
-import "../../chunk-5STPIUCJ.js";
 import {
   assertKnownFlags
 } from "../../chunk-PTBCAI34.js";
 
 // src/cli/doctor.ts
-import { constants as fsConstants } from "node:fs";
-import { access, mkdir } from "node:fs/promises";
-import { resolveCredentials } from "@prismalens/config/credentials";
-import { HARNESS_BINARY } from "@prismalens/config/harness";
-import { isOnPath, resolveHarnessAuth } from "@prismalens/config/harness-auth";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import {
+  ensureAppDataDir,
+  getAppDataDir,
+  secretFileName
+} from "@prismalens/config";
+import {
+  HARNESS_REGISTRY,
+  resolveHarnessModel
+} from "@prismalens/config/harness";
 import {
-  AUTO_SELECT_PROVIDER_IDS,
-  LLM_PROVIDERS
-} from "@prismalens/config/llm";
-import { pingModel } from "@prismalens/config/model";
+  installHints,
+  isOnPath,
+  resolveHarnessSelection,
+  resolveOnPath
+} from "@prismalens/config/harness-selection";
+import { isSrtAvailable, probeHarness } from "@prismalens/engine";
 import { defineCommand } from "citty";
 import consola from "consola";
-function checkHarness(harness) {
-  const binary = HARNESS_BINARY[harness];
-  const pass = isOnPath(binary);
-  const sessionVerdict = harness === "claude-code" ? resolveHarnessAuth("claude-code", { apiKeyPresent: false }) : null;
-  const sessionSuffix = sessionVerdict?.usable && sessionVerdict.route === "cli-session" && sessionVerdict.verified ? ", verified session" : "";
+var MIN_NODE_MAJOR = 22;
+var MIN_NODE_MINOR = 13;
+function checkNodeVersion() {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  const pass = major > MIN_NODE_MAJOR || major === MIN_NODE_MAJOR && minor >= MIN_NODE_MINOR;
   return {
-    name: "Harness binary",
+    name: "Node version",
     pass,
-    detail: pass ? `${binary} found on PATH (harness: ${harness}${sessionSuffix})` : `${binary} not found on PATH \u2014 install the "${harness}" harness`,
+    detail: pass ? `${process.versions.node} (>= ${MIN_NODE_MAJOR}.${MIN_NODE_MINOR} required)` : `${process.versions.node} \u2014 prismalens requires Node >= ${MIN_NODE_MAJOR}.${MIN_NODE_MINOR}`,
     hard: true
   };
 }
-async function checkCredential(config, noPing) {
-  let providerId = config.synth.provider;
-  let creds;
-  if (providerId) {
-    creds = resolveCredentials(providerId, config.synth.base_url);
-  } else {
-    for (const id of AUTO_SELECT_PROVIDER_IDS) {
-      const candidate = resolveCredentials(id, config.synth.base_url);
-      if (candidate.source !== "none") {
-        providerId = id;
-        creds = candidate;
-        break;
-      }
-    }
-    if (!creds) {
-      creds = { providerId: "ollama", source: "none" };
-      providerId = "ollama";
-    }
-  }
-  if (creds.source === "none") {
-    return {
-      name: "LLM credential",
-      pass: false,
-      detail: "none (reports will be RAW harness pass-through) \u2014 not verified",
-      hard: false
-    };
-  }
-  const providerName = LLM_PROVIDERS[providerId].name;
-  if (noPing) {
-    return {
-      name: "LLM credential",
-      pass: true,
-      detail: `${providerName} (source: ${creds.source}) \u2014 ping skipped`,
-      hard: false
-    };
-  }
-  const ping = await pingModel(
-    providerId,
-    config.synth.model,
-    {
-      apiKey: creds.apiKey,
-      baseURL: creds.baseURL
-    }
-  );
-  if (ping.success) {
+function checkAppDataDir() {
+  try {
+    const dir = ensureAppDataDir();
     return {
-      name: "LLM credential",
+      name: "Workspace",
       pass: true,
-      detail: `${providerName} (source: ${creds.source}) \u2014 ping OK`,
-      hard: false
+      detail: dir,
+      hard: true
     };
-  } else {
+  } catch (err) {
     return {
-      name: "LLM credential",
+      name: "Workspace",
       pass: false,
-      detail: `${providerName} (source: ${creds.source}) \u2014 ping failed: ${ping.error}`,
+      detail: `${getAppDataDir()} \u2014 ${err instanceof Error ? err.message : String(err)}`,
       hard: true
     };
   }
 }
-async function checkWorkspace(config) {
-  const baseDir = resolveBaseDir(config.workspace.dir);
-  try {
-    await mkdir(baseDir, { recursive: true });
-    await access(baseDir, fsConstants.W_OK);
+function checkHarnessesOnPath() {
+  return Object.values(HARNESS_REGISTRY).map((descriptor) => {
+    const resolved = resolveOnPath(descriptor.binary);
     return {
-      name: "Workspace",
-      pass: true,
-      detail: `${baseDir} is writable`,
+      name: `Harness: ${descriptor.label}`,
+      pass: resolved !== null,
+      detail: resolved ? `${descriptor.binary} found at ${resolved}` : `${descriptor.binary} not found on PATH`,
       hard: false
     };
-  } catch {
-    return {
-      name: "Workspace",
-      pass: false,
-      detail: `${baseDir} is not writable \u2014 runs cannot persist here`,
+  });
+}
+function checkPath() {
+  const entries = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const head = entries.slice(0, 3).join(", ");
+  return {
+    name: "PATH",
+    pass: entries.length > 0,
+    detail: entries.length === 0 ? "empty" : `${entries.length} entries, starting ${head}${entries.length > 3 ? ", \u2026" : ""}`,
+    hard: false
+  };
+}
+function checkAnyHarnessOnPath(perHarness) {
+  const pass = perHarness.some((c) => c.pass);
+  return {
+    name: "Harness available",
+    pass,
+    detail: pass ? "at least one harness is installed" : `no harness found on PATH. Install one: ${installHints()}`,
+    hard: true
+  };
+}
+async function checkHarnessHandshake() {
+  const installed = Object.values(HARNESS_REGISTRY).filter((descriptor) => isOnPath(descriptor.binary));
+  const results = [];
+  for (const descriptor of installed) {
+    const probe = await probeHarness(descriptor.id);
+    results.push({
+      name: `Harness ACP handshake: ${descriptor.label}`,
+      pass: probe.outcome === "answers-acp",
+      detail: probe.detail,
       hard: false
-    };
+    });
   }
+  return results;
 }
-function checkListenToken(config) {
-  if (config.listen.token) {
-    return {
-      name: "Listen intake",
+function checkAutoSelection() {
+  const envHarness = process.env.PRISMALENS_HARNESS;
+  const selection = resolveHarnessSelection({ envHarness, pinSource: "env" });
+  if (!selection.runnable) {
+    return [
+      {
+        name: "Selected harness",
+        pass: false,
+        detail: selection.reason,
+        hard: false
+      }
+    ];
+  }
+  const model = resolveHarnessModel(selection.harness);
+  return [
+    {
+      name: "Selected harness",
       pass: true,
-      detail: `token configured; \`pl listen\` will serve on port ${config.listen.port}`,
+      detail: `${selection.harness}${selection.auto ? " (auto; a harness saved under Settings \u2192 Harness wins)" : " (pinned by PRISMALENS_HARNESS)"}${selection.verified ? "" : ", not yet verified"}`,
       hard: false
-    };
-  }
+    },
+    {
+      name: "Model",
+      pass: model.source === "product-default",
+      detail: model.source === "product-default" ? `${model.model} (verified default; Settings \u2192 Harness \u2192 Model overrides it)` : `${selection.harness} has no verified default, so the harness picks its own model unless Settings \u2192 Harness \u2192 Model sets one`,
+      hard: false
+    }
+  ];
+}
+function checkSandbox() {
+  const srt = isSrtAvailable();
+  return {
+    name: "Sandbox",
+    pass: srt,
+    detail: srt ? "srt found; runs get an enforced filesystem and egress boundary" : "srt not found; runs use the cooperative process floor, which does not stop a read outside the snapshot. Install @anthropic-ai/sandbox-runtime for an enforced boundary (docs.prismalens.io/cli/sandboxing/)",
+    hard: false
+  };
+}
+function checkWebhookToken() {
+  const filePath = join(
+    getAppDataDir(),
+    secretFileName("PRISMALENS_WEBHOOK_SECRET")
+  );
+  const exists = existsSync(filePath);
+  return {
+    name: "Webhook token",
+    pass: exists,
+    detail: `${filePath} (${exists ? "exists" : "does not exist yet"})`,
+    hard: false
+  };
+}
+function checkPortHost() {
+  const port = process.env.PRISMALENS_PORT ?? "3001";
+  const host = process.env.PRISMALENS_HOST ?? "127.0.0.1";
   return {
-    name: "Listen intake",
-    pass: false,
-    detail: "listen.token is unset \u2014 `pl listen` will refuse to start (set listen.token in prismalens.config.yaml)",
+    name: "Port/host",
+    pass: true,
+    detail: `${host}:${port}`,
     hard: false
   };
 }
 var doctor_default = defineCommand({
   meta: {
     name: "doctor",
-    description: "Preflight check the investigation environment\n\nExamples:\n  $ pl doctor --no-ping"
+    description: "Preflight check the `pl up` environment"
   },
   args: {
-    // citty models `--no-ping` as negation of a `ping` boolean — a literal
-    // `noPing` arg would never receive it.
-    ping: {
-      type: "boolean",
-      description: "Live-ping the LLM credential (disable with --no-ping)",
-      default: true
+    port: {
+      type: "string",
+      description: "Port `pl up` will listen on (default 3001, or PRISMALENS_PORT)"
+    },
+    host: {
+      type: "string",
+      description: "Host `pl up` will bind (default localhost, or PRISMALENS_HOST)"
+    },
+    workspace: {
+      type: "string",
+      description: "Data directory `pl up` will use (default ~/.prismalens, or PRISMALENS_WORKSPACE_DIR)"
     }
   },
   async run({ args, cmd }) {
     try {
       assertKnownFlags(args, cmd);
-      const config = await loadConfig();
-      const harness = config.agent.default;
-      const noPing = !args.ping;
+      if (args.port) process.env.PRISMALENS_PORT = String(args.port);
+      if (args.host) process.env.PRISMALENS_HOST = String(args.host);
+      if (args.workspace) {
+        process.env.PRISMALENS_WORKSPACE_DIR = String(args.workspace);
+      }
+      const harnessChecks = checkHarnessesOnPath();
+      const handshakeChecks = await checkHarnessHandshake();
       const checks = [
-        checkHarness(harness),
-        await checkCredential(config, noPing),
-        await checkWorkspace(config),
-        checkListenToken(config)
+        checkNodeVersion(),
+        checkAppDataDir(),
+        checkPath(),
+        ...harnessChecks,
+        checkAnyHarnessOnPath(harnessChecks),
+        ...handshakeChecks,
+        ...checkAutoSelection(),
+        checkSandbox(),
+        checkWebhookToken(),
+        checkPortHost()
       ];
       consola.log("");
       for (const check of checks) {
@@ -166,8 +209,11 @@ var doctor_default = defineCommand({
       consola.log("");
       const hardFailures = checks.filter((c) => c.hard && !c.pass);
       if (hardFailures.length > 0) {
+        const onlyHarness = hardFailures.every(
+          (c) => c.name === "Harness available"
+        );
         consola.error(
-          `${hardFailures.length} required check(s) failed \u2014 fix the above before investigating.`
+          onlyHarness ? "No harness on PATH. `pl up` still starts, but Investigate stays disabled until one is installed." : `${hardFailures.length} required check(s) failed. Fix the above before running \`pl up\`.`
         );
         process.exit(1);
       }
@@ -179,7 +225,11 @@ var doctor_default = defineCommand({
   }
 });
 export {
-  checkCredential,
-  checkListenToken,
+  checkAnyHarnessOnPath,
+  checkAutoSelection,
+  checkHarnessHandshake,
+  checkHarnessesOnPath,
+  checkSandbox,
+  checkWebhookToken,
   doctor_default as default
 };

package/dist/src/cli/up-console.js

@@ -0,0 +1,16 @@
+import {
+  displayUrl,
+  healthUrl,
+  resolveBind,
+  resolveConsoleMode,
+  resolveLogDir,
+  waitForReady
+} from "../../chunk-HKIFAYVZ.js";
+export {
+  displayUrl,
+  healthUrl,
+  resolveBind,
+  resolveConsoleMode,
+  resolveLogDir,
+  waitForReady
+};

package/dist/src/cli/up.js

@@ -1,3 +1,12 @@
+import {
+  displayUrl,
+  healthUrl,
+  resolveBind,
+  resolveConsoleMode,
+  resolveLogDir,
+  waitForReady
+} from "../../chunk-HKIFAYVZ.js";
+
 // src/cli/up.ts
 import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -6,6 +15,7 @@ import { pathToFileURL } from "node:url";
 import { defineCommand } from "citty";
 import consola from "consola";
 var require2 = createRequire(import.meta.url);
+var READY_TIMEOUT_MS = 6e4;
 function resolvePackagedApi() {
   let manifestPath;
   try {
@@ -48,24 +58,53 @@ var up_default = defineCommand({
     },
     workspace: {
       type: "string",
-      description: "Data directory for the database and secrets (default ~/.prismalens, or PRISMALENS_WORKSPACE_DIR)"
+      description: "Data directory for the database, secrets and logs (default ~/.prismalens, or PRISMALENS_WORKSPACE_DIR)"
+    },
+    verbose: {
+      type: "boolean",
+      description: "Stream every log record to the terminal as well as the log file (default: warnings and errors only)"
     }
   },
   async run({ args }) {
     const app = resolvePackagedApi();
+    process.env.NODE_ENV = "production";
     if (args.port) process.env.PRISMALENS_PORT = String(args.port);
     if (args.host) process.env.PRISMALENS_HOST = String(args.host);
     if (args.workspace) {
       process.env.PRISMALENS_WORKSPACE_DIR = String(args.workspace);
     }
     process.env.PRISMALENS_STATIC_DIR = app.staticDir;
+    process.env.PRISMALENS_LOG_CONSOLE = resolveConsoleMode(
+      process.env,
+      Boolean(args.verbose)
+    );
     const { getAppDataDir, ensureAppDataDir } = await import("@prismalens/config");
     ensureAppDataDir();
     const workspaceDir = getAppDataDir();
     mkdirSync(workspaceDir, { recursive: true });
+    const logDir = resolveLogDir(process.env, workspaceDir);
+    const bind = resolveBind(process.env);
+    const url = displayUrl(bind);
     consola.info(`Workspace: ${workspaceDir}`);
-    consola.info(`Dashboard: ${app.staticDir}`);
+    consola.info(`Logs: ${logDir}`);
+    if (process.env.PRISMALENS_LOG_CONSOLE === "verbose") {
+      consola.info(`Dashboard: ${app.staticDir}`);
+    }
     await import(pathToFileURL(app.main).href);
+    if (bind.protocol === "https") {
+      consola.info(`Starting at ${url}`);
+      return;
+    }
+    const ready = await waitForReady(healthUrl(bind), {
+      timeoutMs: READY_TIMEOUT_MS
+    });
+    if (ready) {
+      consola.success(`PrismaLens is ready at ${url}`);
+    } else {
+      consola.warn(
+        `Not listening after ${READY_TIMEOUT_MS / 1e3}s. Still starting, or stuck: see ${logDir}`
+      );
+    }
   }
 });
 export {

package/node_modules/@prismalens/api/dist/src/app.controller.js

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { Controller, Get } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { Public } from "./core/auth/public.decorator.js";
+import { resolveServiceVersion } from "./shared/utils/service-version.js";
 let AppController = class AppController {
     _configService;
     constructor(_configService) {
@@ -18,7 +19,7 @@ let AppController = class AppController {
     root() {
         return {
             name: "PrismaLens API",
-            version: "0.1.0",
+            version: resolveServiceVersion(),
             edition: "COMMUNITY",
             docs: "/api",
         };

package/node_modules/@prismalens/api/dist/src/app.module.js

@@ -39,31 +39,25 @@ function staticModule() {
     ];
 }
 import { AuthGuard, AuthModule } from "./core/auth/index.js";
-import { LicenseModule } from "./core/license/license.module.js";
 import { PrismaModule } from "./core/prisma/prisma.module.js";
 import { SettingsModule } from "./core/settings/settings.module.js";
 import { SetupModule } from "./core/setup/setup.module.js";
 import { UsersModule } from "./core/users/users.module.js";
-import { DevSeedModule } from "./infrastructure/dev-seed/dev-seed.module.js";
 import { DispatchModule } from "./infrastructure/dispatch/dispatch.module.js";
 import { HealthModule } from "./infrastructure/health/health.module.js";
-import { InternalModule } from "./infrastructure/internal/internal.module.js";
 import { AlertMappingModule } from "./modules/alert-mapping/alert-mapping.module.js";
 import { AlertsModule } from "./modules/alerts/alerts.module.js";
-import { CorrelationModule } from "./modules/correlation/correlation.module.js";
-import { DeploymentsModule } from "./modules/deployments/deployments.module.js";
 import { EventsModule } from "./modules/events/events.module.js";
 import { IncidentsModule } from "./modules/incidents/incidents.module.js";
 import { IntegrationsModule } from "./modules/integrations/integrations.module.js";
 import { InvestigationsModule } from "./modules/investigations/investigations.module.js";
 import { OpenAPIModule } from "./modules/openapi/openapi.module.js";
-import { PostmortemsModule } from "./modules/postmortems/postmortems.module.js";
 import { RecommendationsModule } from "./modules/recommendations/recommendations.module.js";
 import { RepositoriesModule } from "./modules/repositories/repositories.module.js";
-import { ServiceDiscoveryModule } from "./modules/service-discovery/service-discovery.module.js";
 import { ServicesModule } from "./modules/services/services.module.js";
 import { TimelineModule } from "./modules/timeline/timeline.module.js";
 import { WebhooksModule } from "./modules/webhooks/webhooks.module.js";
+import { resolveServiceVersion } from "./shared/utils/service-version.js";
 const orpcLogger = new Logger({ context: "oRPC" });
 let AppModule = class AppModule {
     configure(consumer) {
@@ -83,7 +77,7 @@ AppModule = __decorate([
             LoggerModule.forRoot({
                 service: {
                     name: "prismalens-api",
-                    version: "0.1.0",
+                    version: resolveServiceVersion(),
                     environment: process.env.NODE_ENV ?? "development",
                 },
             }),
@@ -125,27 +119,20 @@ AppModule = __decorate([
             UsersModule,
             SetupModule,
             SettingsModule,
-            LicenseModule,
             HealthModule,
             DispatchModule,
-            InternalModule,
-            DevSeedModule,
             ...staticModule(),
             EventsModule,
             ServicesModule,
             RepositoriesModule,
-            DeploymentsModule,
             AlertsModule,
             AlertMappingModule,
-            CorrelationModule,
             IncidentsModule,
             InvestigationsModule,
             TimelineModule,
-            PostmortemsModule,
             WebhooksModule,
             RecommendationsModule,
             IntegrationsModule,
-            ServiceDiscoveryModule,
             OpenAPIModule,
         ],
         controllers: [AppController],

package/node_modules/@prismalens/api/dist/src/core/auth/auth.guard.js

@@ -33,10 +33,7 @@ let AuthGuard = class AuthGuard {
             if (!session?.user) {
                 throw new UnauthorizedException("Invalid session");
             }
-            request.user = {
-                ...session.user,
-                role: session.user.role ?? undefined,
-            };
+            request.user = session.user;
             request.session = session.session;
             return true;
         }