superacli 1.0.1 → 1.1.2

package/__tests__/plugins-store.test.js

@@ -0,0 +1,115 @@
+const fs = require("fs")
+const os = require("os")
+
+jest.mock("fs")
+jest.mock("os", () => ({
+  homedir: jest.fn(() => "/home/user")
+}))
+
+const {
+  readPluginsLock,
+  writePluginsLock,
+  listInstalledPlugins,
+  getInstalledPluginCommands
+} = require("../cli/plugins-store")
+const path = require("path")
+
+describe("plugins-store", () => {
+  const mockHomedir = "/home/user"
+  const dcliDir = path.join(mockHomedir, ".dcli")
+  const pluginsFile = path.join(dcliDir, "plugins.lock.json")
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    os.homedir.mockReturnValue(mockHomedir)
+  })
+
+  describe("readPluginsLock", () => {
+    test("returns empty lock if file does not exist", () => {
+      fs.existsSync.mockReturnValue(false)
+      const lock = readPluginsLock()
+      expect(lock).toEqual({ version: 1, installed: {} })
+    })
+
+    test("returns parsed lock if file exists", () => {
+      fs.existsSync.mockReturnValue(true)
+      const mockLock = { version: 1, installed: { p1: { name: "p1" } } }
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockLock))
+      const lock = readPluginsLock()
+      expect(lock).toEqual(mockLock)
+    })
+
+    test("returns empty lock if file is invalid JSON", () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue("invalid-json")
+      const lock = readPluginsLock()
+      expect(lock).toEqual({ version: 1, installed: {} })
+    })
+
+    test("returns empty lock if parsed content is not an object", () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue("null")
+      const lock = readPluginsLock()
+      expect(lock).toEqual({ version: 1, installed: {} })
+    })
+
+    test("ensures installed field is an object", () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({ version: 1 }))
+      const lock = readPluginsLock()
+      expect(lock.installed).toEqual({})
+    })
+  })
+
+  describe("writePluginsLock", () => {
+    test("creates directory if missing and writes file", () => {
+      fs.existsSync.mockReturnValue(false)
+      const lock = { version: 1, installed: {} }
+      writePluginsLock(lock)
+      expect(fs.mkdirSync).toHaveBeenCalledWith(dcliDir, { recursive: true })
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        pluginsFile,
+        expect.stringContaining('"version": 1')
+      )
+    })
+  })
+
+  describe("listInstalledPlugins", () => {
+    test("returns array of plugins", () => {
+      fs.existsSync.mockReturnValue(true)
+      const p1 = { name: "p1" }
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        installed: { p1 }
+      }))
+      const list = listInstalledPlugins()
+      expect(list).toEqual([p1])
+    })
+  })
+
+  describe("getInstalledPluginCommands", () => {
+    test("returns flattened array of commands", () => {
+      fs.existsSync.mockReturnValue(true)
+      const c1 = { id: "c1" }
+      const c2 = { id: "c2" }
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        installed: {
+          p1: { commands: [c1] },
+          p2: { commands: [c2] }
+        }
+      }))
+      const commands = getInstalledPluginCommands()
+      expect(commands).toEqual([c1, c2])
+    })
+
+    test("handles plugins with missing commands field", () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        installed: {
+          p1: { name: "p1" }
+        }
+      }))
+      const commands = getInstalledPluginCommands()
+      expect(commands).toEqual([])
+    })
+  })
+})

package/__tests__/pnpm-plugin.test.js

@@ -0,0 +1,81 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakePnpmBinary(dir) {
+  const bin = path.join(dir, "pnpm")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('9.0.0-test'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("pnpm plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-pnpm-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-pnpm-"))
+  writeFakePnpmBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/pnpm --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove pnpm --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes cli version wrapped command", () => {
+    const r = runNoServer("pnpm cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pnpm.cli.version")
+    expect(data.data.raw).toBe("9.0.0-test")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("pnpm search react --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pnpm.passthrough")
+    expect(data.data.args[0]).toBe("search")
+    expect(data.data.args).toContain("react")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports pnpm dependency as healthy", () => {
+    const r = runNoServer("plugins doctor pnpm --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "pnpm" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/poetry-plugin.test.js

@@ -0,0 +1,83 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakePoetryBinary(dir) {
+  const bin = path.join(dir, "poetry")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('Poetry (version 2.1.1-test)'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("poetry plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-poetry-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-poetry-"))
+  writeFakePoetryBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/poetry --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove poetry --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes cli version wrapped command", () => {
+    const r = runNoServer("poetry cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("poetry.cli.version")
+    expect(data.data.raw).toBe("Poetry (version 2.1.1-test)")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("poetry self show --format json --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("poetry.passthrough")
+    expect(data.data.args[0]).toBe("self")
+    expect(data.data.args[1]).toBe("show")
+    expect(data.data.args).toContain("--format")
+    expect(data.data.args).toContain("json")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports poetry dependency as healthy", () => {
+    const r = runNoServer("plugins doctor poetry --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "poetry" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/process-adapter.test.js

@@ -0,0 +1,143 @@
+const { execute } = require("../cli/adapters/process")
+const { spawn, spawnSync } = require("child_process")
+const EventEmitter = require("events")
+const os = require("os")
+
+jest.mock("child_process")
+
+describe("process adapter", () => {
+  let mockChild
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockChild = new EventEmitter()
+    mockChild.stdout = new EventEmitter()
+    mockChild.stdout.setEncoding = jest.fn()
+    mockChild.stderr = new EventEmitter()
+    mockChild.stderr.setEncoding = jest.fn()
+    mockChild.stdin = { write: jest.fn(), end: jest.fn() }
+    mockChild.kill = jest.fn()
+    spawn.mockReturnValue(mockChild)
+    spawnSync.mockReturnValue({ status: 0, stdout: "/bin/node" })
+  })
+
+  test("detectInteractiveFlags coverage (short flags, long flag with equals)", async () => {
+    const oldTTY = process.stdout.isTTY
+    process.stdout.isTTY = false
+    try {
+      await expect(execute({
+        adapterConfig: { 
+          command: "node", 
+          passthrough: true,
+          interactiveFlags: ["--tty", "-i", "-t"] 
+        },
+      }, { __rawArgs: ["--tty=true", "-it"] })).rejects.toMatchObject({ code: 91 })
+    } finally {
+      process.stdout.isTTY = oldTTY
+    }
+  })
+
+  test("throws if command missing", async () => {
+    await expect(execute({ adapterConfig: {} }, {})).rejects.toThrow(/requires adapterConfig.command/)
+  })
+
+  test("successfully executes command and parses JSON", async () => {
+    const promise = execute({
+      adapterConfig: { command: "node", baseArgs: ["-e", "ok"], parseJson: true }
+    }, { foo: "bar" })
+
+    mockChild.stdout.emit("data", '{"result": true}')
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ result: true })
+  })
+
+  test("handles spawn error ENOENT", async () => {
+    const promise = execute({ adapterConfig: { command: "node" } }, {})
+    mockChild.emit("error", { code: "ENOENT" })
+    await expect(promise).rejects.toMatchObject({ code: 85 })
+  })
+
+  test("handles timeout", async () => {
+    jest.useFakeTimers()
+    const promise = execute({ adapterConfig: { command: "node", timeout_ms: 100 } }, {})
+    jest.advanceTimersByTime(200)
+    await expect(promise).rejects.toThrow("timed out")
+    jest.useRealTimers()
+  })
+
+  test("handles non-zero exit", async () => {
+    const promise = execute({ adapterConfig: { command: "node" } }, {})
+    mockChild.stderr.emit("data", "error")
+    mockChild.emit("close", 1)
+    await expect(promise).rejects.toThrow("Process adapter failed")
+  })
+  
+  test("handles passthroughInteractive", async () => {
+    const promise = execute({
+      adapterConfig: { command: "node", passthrough: true }
+    }, { __passthroughInteractive: true })
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(result.passthrough).toBe(true)
+  })
+
+  test("includes nonTtyBaseArgs", async () => {
+    const oldTTY = process.stdout.isTTY
+    process.stdout.isTTY = false
+    try {
+      const promise = execute({
+        adapterConfig: { command: "node", nonTtyBaseArgs: ["--no-tty"] }
+      }, {})
+      mockChild.emit("close", 0)
+      await promise
+      expect(spawn).toHaveBeenCalledWith("node", ["--no-tty"], expect.anything())
+    } finally {
+      process.stdout.isTTY = oldTTY
+    }
+  })
+
+  test("handles JSON parse error", async () => {
+    const promise = execute({ adapterConfig: { command: "node", parseJson: true } }, {})
+    mockChild.stdout.emit("data", "invalid")
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(result.raw).toBe("invalid")
+  })
+
+  test("handles parseJson false", async () => {
+    const promise = execute({ adapterConfig: { command: "node", parseJson: false } }, {})
+    mockChild.stdout.emit("data", "text")
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(result.raw).toBe("text")
+  })
+
+  test("streams jsonl events incrementally", async () => {
+    const onStreamEvent = jest.fn()
+    const promise = execute({ adapterConfig: { command: "node", stream: "jsonl" } }, {}, { onStreamEvent })
+    mockChild.stdout.emit("data", '{"type":"say","text":"one"}\n{"type":"say"')
+    mockChild.stdout.emit("data", ',"text":"two"}\n')
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(onStreamEvent).toHaveBeenCalledTimes(2)
+    expect(onStreamEvent.mock.calls[0][0]).toEqual({ type: "say", text: "one" })
+    expect(result).toEqual({
+      streamed: true,
+      stream: "jsonl",
+      event_count: 2,
+      last_event: { type: "say", text: "two" }
+    })
+  })
+
+  test("flushes trailing jsonl line without newline", async () => {
+    const onStreamEvent = jest.fn()
+    const promise = execute({ adapterConfig: { command: "node", stream: "jsonl" } }, {}, { onStreamEvent })
+    mockChild.stdout.emit("data", '{"type":"task_started","taskId":"123"}')
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(onStreamEvent).toHaveBeenCalledWith({ type: "task_started", taskId: "123" })
+    expect(result.event_count).toBe(1)
+  })
+})

package/__tests__/pulumi-plugin.test.js

@@ -0,0 +1,81 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakePulumiBinary(dir) {
+  const bin = path.join(dir, "pulumi")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version') { console.log('v3.160.0-test'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("pulumi plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-pulumi-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-pulumi-"))
+  writeFakePulumiBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/pulumi --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove pulumi --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes cli version wrapped command", () => {
+    const r = runNoServer("pulumi cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pulumi.cli.version")
+    expect(data.data.raw).toBe("v3.160.0-test")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("pulumi stack ls --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pulumi.passthrough")
+    expect(data.data.args[0]).toBe("stack")
+    expect(data.data.args[1]).toBe("ls")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports pulumi dependency as healthy", () => {
+    const r = runNoServer("plugins doctor pulumi --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "pulumi" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/railway-plugin.test.js

@@ -0,0 +1,84 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeRailwayBinary(dir) {
+  const bin = path.join(dir, "railway")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('railway 3.0.0-test'); process.exit(0); }",
+    "if (args[0] === 'whoami' && args.includes('--json')) {",
+    "  console.log(JSON.stringify({ user: { name: 'mock-railway-user', email: 'mock@example.com' } }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("railway plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-railway-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-railway-"))
+  writeFakeRailwayBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/railway --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove railway --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account whoami wrapped command", () => {
+    const r = runNoServer("railway account whoami --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("railway.account.whoami")
+    expect(data.data.user.name).toBe("mock-railway-user")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("railway list --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("railway.passthrough")
+    expect(data.data.args[0]).toBe("list")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports railway dependency as healthy", () => {
+    const r = runNoServer("plugins doctor railway --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "railway" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/server-app.test.js

@@ -0,0 +1,67 @@
+var mockApp
+const express = require("express")
+
+const mockStorage = {
+  get: jest.fn(),
+  set: jest.fn(),
+  listKeys: jest.fn().mockResolvedValue([])
+}
+
+jest.mock("../server/storage/adapter", () => ({
+  getStorage: jest.fn(() => mockStorage)
+}))
+
+jest.mock("express", () => {
+  const mApp = {
+    use: jest.fn(),
+    set: jest.fn(),
+    get: jest.fn(),
+    listen: jest.fn((port, cb) => {
+      if (cb) cb();
+    }),
+    post: jest.fn()
+  }
+  mockApp = mApp;
+  const mExpress = jest.fn(() => mApp)
+  mExpress.json = jest.fn(() => (req, res, next) => next())
+  mExpress.urlencoded = jest.fn(() => (req, res, next) => next())
+  mExpress.static = jest.fn(() => (req, res, next) => next())
+  mExpress.Router = jest.fn(() => ({
+    get: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    delete: jest.fn(),
+    use: jest.fn(),
+    stack: []
+  }))
+  return mExpress
+})
+
+describe("server app", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.resetModules()
+    jest.spyOn(console, "log").mockImplementation()
+    jest.spyOn(console, "error").mockImplementation()
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  test("initializes app and starts listening", () => {
+    require("../server/app")
+    expect(mockApp.listen).toHaveBeenCalled()
+  })
+
+  test("handles start-up error", () => {
+    const { getStorage } = require("../server/storage/adapter")
+    getStorage.mockImplementationOnce(() => { throw new Error("fatal") })
+    const mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+    
+    require("../server/app")
+    
+    expect(mockExit).toHaveBeenCalledWith(1)
+    mockExit.mockRestore()
+  })
+})