chore: apply code formatting and linting

- format long import statements with consistent line wrapping
- apply consistent indentation across client and server modules
- remove generated tsconfig.tsbuildinfo file

server/test/browser.controller.spec.ts

@@ -3,6 +3,8 @@ import { getRepositoryToken } from "@nestjs/typeorm";
 import request from "supertest";
 import { buildTestApp } from "./app.harness";
 import { SessionEntity } from "../src/session/session.entity";
+import { EnvironmentEntity } from "../src/environment/environment.entity";
+import { CredentialEntity } from "../src/credential/credential.entity";
 import { Repository } from "typeorm";
 
 /**
@@ -15,6 +17,8 @@ import { Repository } from "typeorm";
 describe("BrowserController", () => {
   let app: INestApplication;
   let sessionRepo: Repository<SessionEntity>;
+  let environmentRepo: Repository<EnvironmentEntity>;
+  let credentialRepo: Repository<CredentialEntity>;
 
   const FAKE_SESSION = "test-browser-session";
 
@@ -23,6 +27,12 @@ describe("BrowserController", () => {
     sessionRepo = app.get<Repository<SessionEntity>>(
       getRepositoryToken(SessionEntity),
     );
+    environmentRepo = app.get<Repository<EnvironmentEntity>>(
+      getRepositoryToken(EnvironmentEntity),
+    );
+    credentialRepo = app.get<Repository<CredentialEntity>>(
+      getRepositoryToken(CredentialEntity),
+    );
 
     // Seed a session with minimal but valid JSON so the browser code can
     // deserialise it (it will still fail to open a real page, tested separately)
@@ -40,6 +50,33 @@ describe("BrowserController", () => {
     await app.close();
   });
 
+  async function createEnvironment(
+    data: Record<string, string | undefined>,
+    name = `browser-env-${Math.random().toString(36).slice(2, 8)}`,
+  ): Promise<string> {
+    const environment = await environmentRepo.save(
+      environmentRepo.create({
+        name,
+        data,
+      }),
+    );
+    return environment.id;
+  }
+
+  async function createCredential(
+    data: Record<string, unknown>,
+    name = `browser-cred-${Math.random().toString(36).slice(2, 8)}`,
+  ): Promise<string> {
+    const credential = await credentialRepo.save(
+      credentialRepo.create({
+        name,
+        data: JSON.stringify(data),
+        lastUsedAt: null,
+      }),
+    );
+    return credential.id;
+  }
+
   // ── POST /open ─────────────────────────────────────────────────────────────
 
   describe("POST /open", () => {
@@ -137,35 +174,46 @@ describe("BrowserController", () => {
     });
 
     it("exposes environment via context.env in a named session", async () => {
+      const environmentId = await createEnvironment({
+        BASE_URL: "https://env.example.com",
+      });
+
       const res = await request(app.getHttpServer())
         .post("/exec")
         .send({
           sessionName: "no-such-session",
           code: "return context.env.BASE_URL;",
-          environment: { BASE_URL: "https://env.example.com" },
+          environmentId,
         })
         .expect(201);
       expect(res.body).toEqual({ result: "https://env.example.com" });
     });
 
     it("exposes environment via context.env in a sessionless exec", async () => {
+      const environmentId = await createEnvironment({ KEY: "value123" });
+
       const res = await request(app.getHttpServer())
         .post("/exec")
         .send({
           code: "return context.env.KEY;",
-          environment: { KEY: "value123" },
+          environmentId,
         })
         .expect(201);
       expect(res.body).toEqual({ result: "value123" });
     });
 
     it("exposes credentials via context.getCredential in a named session", async () => {
+      const credentialId = await createCredential({
+        username: "user1",
+        password: "pass1",
+      });
+
       const res = await request(app.getHttpServer())
         .post("/exec")
         .send({
           sessionName: "no-such-session",
           code: "return context.getCredential('admin');",
-          credentials: { admin: { username: "user1", password: "pass1" } },
+          credentials: { admin: credentialId },
         })
         .expect(201);
       expect(res.body).toEqual({
@@ -174,11 +222,13 @@ describe("BrowserController", () => {
     });
 
     it("exposes credentials via context.getCredential in a sessionless exec", async () => {
+      const credentialId = await createCredential({ token: "abc" });
+
       const res = await request(app.getHttpServer())
         .post("/exec")
         .send({
           code: "return context.getCredential('svc');",
-          credentials: { svc: { token: "abc" } },
+          credentials: { svc: credentialId },
         })
         .expect(201);
       expect(res.body).toEqual({ result: { token: "abc" } });

server/test/environment.controller.spec.ts

@@ -160,7 +160,9 @@ describe("EnvironmentController", () => {
     });
 
     it("returns 404 for unknown id", async () => {
-      await request(app.getHttpServer()).get("/environments/00000000-0000-0000-0000-000000000001").expect(404);
+      await request(app.getHttpServer())
+        .get("/environments/00000000-0000-0000-0000-000000000001")
+        .expect(404);
     });
 
     it("returns 400 for non-numeric id", async () => {

server/test/mcp.controller.spec.ts

@@ -75,7 +75,10 @@ describe("McpController", () => {
     it("returns MCP error for removed tool", async () => {
       const { status, rpc } = await mcpCall("list_keys");
       expect(status).toBe(200);
-      const result = rpc.result as { isError: boolean; content?: { text: string }[] };
+      const result = rpc.result as {
+        isError: boolean;
+        content?: { text: string }[];
+      };
       expect(result.isError).toBe(true);
     });
   });

server/test/scenario.controller.spec.ts

@@ -163,7 +163,9 @@ describe("ScenarioController", () => {
     });
 
     it("returns 404 for unknown id", async () => {
-      await request(app.getHttpServer()).get("/scenarios/00000000-0000-0000-0000-000000000001").expect(404);
+      await request(app.getHttpServer())
+        .get("/scenarios/00000000-0000-0000-0000-000000000001")
+        .expect(404);
     });
   });
 
@@ -199,7 +201,9 @@ describe("ScenarioController", () => {
     });
 
     it("returns 404 for unknown id", async () => {
-      await request(app.getHttpServer()).delete("/scenarios/00000000-0000-0000-0000-000000000001").expect(404);
+      await request(app.getHttpServer())
+        .delete("/scenarios/00000000-0000-0000-0000-000000000001")
+        .expect(404);
     });
   });
 
@@ -327,8 +331,8 @@ describe("ScenarioController", () => {
     it("reorders by exact target index", async () => {
       const sc = await createScenario();
       const stepA = await createStep(sc.id, { title: "A" });
-      const stepB = await createStep(sc.id, { title: "B" });
-      const stepC = await createStep(sc.id, { title: "C" });
+      await createStep(sc.id, { title: "B" });
+      await createStep(sc.id, { title: "C" });
       const stepD = await createStep(sc.id, { title: "D" });
 
       await request(app.getHttpServer())
@@ -339,12 +343,15 @@ describe("ScenarioController", () => {
       let res = await request(app.getHttpServer())
         .get(`/scenarios/${sc.id}`)
         .expect(200);
-      expect(
-        res.body.steps.map((s: { title: string }) => s.title),
-      ).toEqual(["B", "C", "A", "D"]);
-      expect(
-        res.body.steps.map((s: { order: number }) => s.order),
-      ).toEqual([0, 1, 2, 3]);
+      expect(res.body.steps.map((s: { title: string }) => s.title)).toEqual([
+        "B",
+        "C",
+        "A",
+        "D",
+      ]);
+      expect(res.body.steps.map((s: { order: number }) => s.order)).toEqual([
+        0, 1, 2, 3,
+      ]);
 
       await request(app.getHttpServer())
         .patch(`/scenarios/${sc.id}/steps/${stepD.id}`)
@@ -354,12 +361,15 @@ describe("ScenarioController", () => {
       res = await request(app.getHttpServer())
         .get(`/scenarios/${sc.id}`)
         .expect(200);
-      expect(
-        res.body.steps.map((s: { title: string }) => s.title),
-      ).toEqual(["D", "B", "C", "A"]);
-      expect(
-        res.body.steps.map((s: { order: number }) => s.order),
-      ).toEqual([0, 1, 2, 3]);
+      expect(res.body.steps.map((s: { title: string }) => s.title)).toEqual([
+        "D",
+        "B",
+        "C",
+        "A",
+      ]);
+      expect(res.body.steps.map((s: { order: number }) => s.order)).toEqual([
+        0, 1, 2, 3,
+      ]);
     });
   });
 
@@ -395,9 +405,7 @@ describe("ScenarioController", () => {
       expect(Array.isArray(res.stepRuns)).toBe(true);
       expect(res.stepRuns).toHaveLength(3);
 
-      const statuses = res.stepRuns.map(
-        (s: { status: string }) => s.status,
-      );
+      const statuses = res.stepRuns.map((s: { status: string }) => s.status);
       expect(statuses[0]).toBe("pending");
       expect(statuses[1]).toBe("waiting");
       expect(statuses[2]).toBe("waiting");
@@ -495,9 +503,18 @@ describe("ScenarioController", () => {
 
     it("exports steps ordered by sequential position", async () => {
       const sc = await createScenario("export-order");
-      await createStep(sc.id, { sessionName: "s", execCode: "return 'first';" });
-      await createStep(sc.id, { sessionName: "s", execCode: "return 'second';" });
-      await createStep(sc.id, { sessionName: "s", execCode: "return 'third';" });
+      await createStep(sc.id, {
+        sessionName: "s",
+        execCode: "return 'first';",
+      });
+      await createStep(sc.id, {
+        sessionName: "s",
+        execCode: "return 'second';",
+      });
+      await createStep(sc.id, {
+        sessionName: "s",
+        execCode: "return 'third';",
+      });
 
       const res = await request(app.getHttpServer())
         .get(`/scenarios/${sc.id}/export`)
@@ -616,9 +633,7 @@ describe("ScenarioController", () => {
 
       expect(importRes.body.name).toBe("roundtrip");
       expect(importRes.body.steps).toHaveLength(1);
-      expect(importRes.body.steps[0].execCode).toBe(
-        exported.steps[0].execCode,
-      );
+      expect(importRes.body.steps[0].execCode).toBe(exported.steps[0].execCode);
     });
 
     it("imports with empty steps array", async () => {
@@ -663,7 +678,7 @@ describe("ScenarioController", () => {
       const sc = await createScenario();
       await createStep(sc.id, { order: 0 });
       const runRes = await createRun(sc.id);
-        const runId = runRes.id;
+      const runId = runRes.id;
 
       const res = await request(app.getHttpServer())
         .get(`/scenarios/${sc.id}/run/${runId}`)
@@ -766,7 +781,9 @@ describe("ScenarioController", () => {
     it("returns 404 for unknown run", async () => {
       const sc = await createScenario();
       await request(app.getHttpServer())
-        .post(`/scenarios/${sc.id}/run/00000000-0000-0000-0000-000000000001/wait`)
+        .post(
+          `/scenarios/${sc.id}/run/00000000-0000-0000-0000-000000000001/wait`,
+        )
         .expect(404);
     });
 

server/test/session.controller.spec.ts

@@ -141,7 +141,9 @@ describe("SessionController", () => {
     });
 
     it("returns 404 for unknown id", async () => {
-      await request(app.getHttpServer()).delete("/sessions/00000000-0000-0000-0000-000000000001").expect(404);
+      await request(app.getHttpServer())
+        .delete("/sessions/00000000-0000-0000-0000-000000000001")
+        .expect(404);
     });
 
     it("returns 400 for non-numeric id", async () => {