@cuongtran001/kanna 0.39.2

package/src/server/test-helpers/wait-for.ts

@@ -0,0 +1,14 @@
+/** Polls until `condition()` returns true or `timeoutMs` elapses. */
+export async function waitFor(
+  condition: () => boolean,
+  timeoutMs = 2000,
+  label = "condition",
+): Promise<void> {
+  const start = Date.now()
+  while (!condition()) {
+    if (Date.now() - start > timeoutMs) {
+      throw new Error(`Timed out waiting for ${label}`)
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+}

package/src/server/title-generation.live.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test"
+import { CodexAppServerManager } from "./codex-app-server"
+import { fallbackTitleFromMessage, generateTitleForChatDetailed } from "./generate-title"
+import { QuickResponseAdapter, runClaudeStructured, runCodexStructured } from "./quick-response"
+
+const shouldRunLiveTests = process.env.KANNA_RUN_LIVE_TITLE_TESTS === "1"
+const LIVE_MESSAGE = "Please help me debug a websocket reconnection issue in a Bun server app"
+
+if (shouldRunLiveTests) {
+  describe("live title generation", () => {
+    test("generates a title with Claude", async () => {
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured,
+        runCodexStructured: async () => {
+          throw new Error("Codex fallback should not be used in the Claude live title test")
+        },
+      })
+
+      const result = await generateTitleForChatDetailed(LIVE_MESSAGE, process.cwd(), adapter)
+
+      expect(result.usedFallback).toBe(false)
+      expect(result.failureMessage).toBeNull()
+      expect(typeof result.title).toBe("string")
+      expect(result.title).not.toBe(fallbackTitleFromMessage(LIVE_MESSAGE))
+    }, 15_000)
+
+    test("generates a title with Codex", async () => {
+      const codexManager = new CodexAppServerManager()
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Claude should not be used in the Codex live title test")
+        },
+        runCodexStructured: async (args) => runCodexStructured(codexManager, args),
+      })
+
+      const result = await generateTitleForChatDetailed(LIVE_MESSAGE, process.cwd(), adapter)
+
+      expect(result.usedFallback).toBe(false)
+      expect(result.failureMessage).toBeNull()
+      expect(typeof result.title).toBe("string")
+      expect(result.title).not.toBe(fallbackTitleFromMessage(LIVE_MESSAGE))
+    }, 15_000)
+  })
+}

package/src/server/update-manager.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, test } from "bun:test"
+import { UpdateManager } from "./update-manager"
+import { UpdateInstallError, type UpdateChecker, type UpdateReloader } from "./update-strategy"
+
+class FakeChecker implements UpdateChecker {
+  calls = 0
+  constructor(private results: Array<{ latestVersion: string; updateAvailable: boolean }>) {}
+  async check() {
+    const result = this.results[Math.min(this.calls, this.results.length - 1)]
+    this.calls += 1
+    return result
+  }
+}
+
+class FakeReloader implements UpdateReloader {
+  calls = 0
+  constructor(private onReload: () => Promise<void> = async () => {}) {}
+  async reload() {
+    this.calls += 1
+    await this.onReload()
+  }
+}
+
+describe("UpdateManager", () => {
+  test("tracks update lifecycle events", async () => {
+    const events: Array<{ name: string; properties?: Record<string, unknown> }> = []
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      checker: new FakeChecker([{ latestVersion: "0.13.0", updateAvailable: true }]),
+      reloader: new FakeReloader(),
+      trackEvent: (eventName, properties) => {
+        events.push({ name: eventName, properties })
+      },
+    })
+
+    await manager.checkForUpdates({ force: true })
+    await manager.installUpdate()
+
+    expect(events).toEqual([
+      {
+        name: "update_checked",
+        properties: {
+          latest_version: "0.13.0",
+        },
+      },
+      {
+        name: "update_installed",
+        properties: {
+          latest_version: "0.13.0",
+        },
+      },
+    ])
+  })
+
+  test("detects available updates", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      checker: new FakeChecker([{ latestVersion: "0.13.0", updateAvailable: true }]),
+      reloader: new FakeReloader(),
+    })
+    const snapshot = await manager.checkForUpdates({ force: true })
+    expect(snapshot.status).toBe("available")
+    expect(snapshot.updateAvailable).toBe(true)
+    expect(snapshot.latestVersion).toBe("0.13.0")
+    expect(snapshot.installAction).toBe("restart")
+    expect(snapshot.reloadRequestedAt).toBeNull()
+  })
+
+  test("bypasses cache when force is true", async () => {
+    const checker = new FakeChecker([
+      { latestVersion: "0.12.1", updateAvailable: true },
+      { latestVersion: "0.13.0", updateAvailable: true },
+    ])
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      checker,
+      reloader: new FakeReloader(),
+    })
+    await manager.checkForUpdates()
+    await manager.checkForUpdates({ force: true })
+    expect(checker.calls).toBe(2)
+    expect(manager.getSnapshot().latestVersion).toBe("0.13.0")
+  })
+
+  test("surfaces reloader failures without clearing the running version", async () => {
+    const reloader = new FakeReloader(async () => {
+      throw new UpdateInstallError(
+        "This update is still propagating. Try again in a few minutes.",
+        "version_not_live_yet",
+        "Update not live yet",
+      )
+    })
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      checker: new FakeChecker([{ latestVersion: "0.13.0", updateAvailable: true }]),
+      reloader,
+    })
+    await manager.checkForUpdates({ force: true })
+    const result = await manager.installUpdate()
+    expect(result).toEqual({
+      ok: false,
+      action: "restart",
+      errorCode: "version_not_live_yet",
+      userTitle: "Update not live yet",
+      userMessage: "This update is still propagating. Try again in a few minutes.",
+    })
+    expect(reloader.calls).toBe(1)
+    expect(manager.getSnapshot().status).toBe("error")
+    expect(manager.getSnapshot().currentVersion).toBe("0.12.0")
+  })
+
+  test("falls back to generic errorCode/userTitle when reloader throws a plain Error", async () => {
+    const reloader = new FakeReloader(async () => {
+      throw new Error("random failure")
+    })
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      checker: new FakeChecker([{ latestVersion: "0.13.0", updateAvailable: true }]),
+      reloader,
+    })
+    await manager.checkForUpdates({ force: true })
+    const result = await manager.installUpdate()
+    expect(result).toEqual({
+      ok: false,
+      action: "restart",
+      errorCode: "install_failed",
+      userTitle: "Update failed",
+      userMessage: "random failure",
+    })
+    expect(manager.getSnapshot().status).toBe("error")
+    expect(manager.getSnapshot().error).toBe("random failure")
+  })
+
+  test("always exposes an available reload action in dev mode", async () => {
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      checker: new FakeChecker([{ latestVersion: "9.9.9", updateAvailable: true }]),
+      reloader: new FakeReloader(),
+      devMode: true,
+    })
+    expect(manager.getSnapshot()).toMatchObject({
+      status: "available",
+      updateAvailable: true,
+      installAction: "restart",
+      reloadRequestedAt: null,
+    })
+    const result = await manager.installUpdate()
+    expect(result).toEqual({
+      ok: true,
+      action: "restart",
+      errorCode: null,
+      userTitle: null,
+      userMessage: null,
+    })
+    expect(manager.getSnapshot().status).toBe("restart_pending")
+    expect(typeof manager.getSnapshot().reloadRequestedAt).toBe("number")
+  })
+})

package/src/server/update-manager.ts

@@ -0,0 +1,222 @@
+import type { UpdateInstallResult, UpdateSnapshot } from "../shared/types"
+import { UpdateInstallError, type UpdateChecker, type UpdateReloader } from "./update-strategy"
+
+const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000
+
+export interface UpdateManagerDeps {
+  currentVersion: string
+  checker: UpdateChecker
+  reloader: UpdateReloader
+  devMode?: boolean
+  trackEvent?: (eventName: string, properties?: Record<string, unknown>) => void
+}
+
+export class UpdateManager {
+  private readonly deps: UpdateManagerDeps
+  private readonly listeners = new Set<(snapshot: UpdateSnapshot) => void>()
+  private snapshot: UpdateSnapshot
+  private checkPromise: Promise<UpdateSnapshot> | null = null
+  private installPromise: Promise<UpdateInstallResult> | null = null
+
+  constructor(deps: UpdateManagerDeps) {
+    this.deps = deps
+    this.snapshot = {
+      currentVersion: deps.currentVersion,
+      latestVersion: deps.devMode ? `${deps.currentVersion}-dev` : null,
+      status: deps.devMode ? "available" : "idle",
+      updateAvailable: Boolean(deps.devMode),
+      lastCheckedAt: deps.devMode ? Date.now() : null,
+      error: null,
+      installAction: "restart",
+      reloadRequestedAt: null,
+    }
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: UpdateSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async checkForUpdates(options: { force?: boolean } = {}) {
+    if (this.deps.devMode) return this.snapshot
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") return this.snapshot
+    if (this.checkPromise) return this.checkPromise
+    if (!options.force && this.snapshot.lastCheckedAt && Date.now() - this.snapshot.lastCheckedAt < UPDATE_CACHE_TTL_MS) {
+      return this.snapshot
+    }
+
+    this.setSnapshot({ ...this.snapshot, status: "checking", error: null, reloadRequestedAt: null })
+
+    const checkPromise = this.runCheck()
+    this.checkPromise = checkPromise
+    try {
+      return await checkPromise
+    } finally {
+      if (this.checkPromise === checkPromise) this.checkPromise = null
+    }
+  }
+
+  async forceReload(): Promise<UpdateInstallResult> {
+    if (this.deps.devMode) {
+      this.setSnapshot({ ...this.snapshot, status: "restart_pending", reloadRequestedAt: Date.now(), error: null })
+      return { ok: true, action: "restart", errorCode: null, userTitle: null, userMessage: null }
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return { ok: true, action: "restart", errorCode: null, userTitle: null, userMessage: null }
+    }
+
+    this.setSnapshot({ ...this.snapshot, status: "updating", error: null, reloadRequestedAt: null })
+
+    try {
+      await this.deps.reloader.reload()
+    } catch (error) {
+      const installError = error instanceof UpdateInstallError ? error : null
+      const message = error instanceof Error ? error.message : String(error)
+      this.setSnapshot({ ...this.snapshot, status: "error", error: message, reloadRequestedAt: null })
+      return {
+        ok: false,
+        action: "restart",
+        errorCode: installError?.errorCode ?? "install_failed",
+        userTitle: installError?.userTitle ?? "Re-deploy failed",
+        userMessage: installError?.message ?? message,
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "restart_pending",
+      error: null,
+      reloadRequestedAt: Date.now(),
+    })
+    return { ok: true, action: "restart", errorCode: null, userTitle: null, userMessage: null }
+  }
+
+  async installUpdate(): Promise<UpdateInstallResult> {
+    if (this.deps.devMode) {
+      this.deps.trackEvent?.("update_installed", {
+        latest_version: this.snapshot.latestVersion,
+      })
+      this.setSnapshot({ ...this.snapshot, status: "updating", error: null, reloadRequestedAt: null })
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "restart_pending",
+        updateAvailable: false,
+        error: null,
+        reloadRequestedAt: Date.now(),
+      })
+      return { ok: true, action: "restart", errorCode: null, userTitle: null, userMessage: null }
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return {
+        ok: this.snapshot.updateAvailable,
+        action: "restart",
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }
+    }
+
+    if (this.installPromise) return this.installPromise
+
+    const installPromise = this.runInstall()
+    this.installPromise = installPromise
+    try {
+      return await installPromise
+    } finally {
+      if (this.installPromise === installPromise) this.installPromise = null
+    }
+  }
+
+  private async runCheck() {
+    try {
+      const { latestVersion, updateAvailable } = await this.deps.checker.check()
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        latestVersion,
+        updateAvailable,
+        status: updateAvailable ? "available" : "up_to_date",
+        lastCheckedAt: Date.now(),
+        error: null,
+        reloadRequestedAt: null,
+      }
+      this.setSnapshot(nextSnapshot)
+      this.deps.trackEvent?.("update_checked", {
+        latest_version: latestVersion,
+      })
+      return nextSnapshot
+    } catch (error) {
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        status: "error",
+        lastCheckedAt: Date.now(),
+        error: error instanceof Error ? error.message : String(error),
+        reloadRequestedAt: null,
+      }
+      this.setSnapshot(nextSnapshot)
+      this.deps.trackEvent?.("update_failed", {
+        latest_version: this.snapshot.latestVersion,
+      })
+      return nextSnapshot
+    }
+  }
+
+  private async runInstall(): Promise<UpdateInstallResult> {
+    if (!this.snapshot.updateAvailable) {
+      const snapshot = await this.checkForUpdates({ force: true })
+      if (!snapshot.updateAvailable) {
+        return { ok: false, action: "restart", errorCode: null, userTitle: null, userMessage: null }
+      }
+    }
+
+    this.setSnapshot({ ...this.snapshot, status: "updating", error: null, reloadRequestedAt: null })
+
+    try {
+      await this.deps.reloader.reload()
+    } catch (error) {
+      const installError = error instanceof UpdateInstallError ? error : null
+      const message = error instanceof Error ? error.message : String(error)
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "error",
+        error: message,
+        reloadRequestedAt: null,
+      })
+      this.deps.trackEvent?.("update_failed", {
+        latest_version: null,
+      })
+      return {
+        ok: false,
+        action: "restart",
+        errorCode: installError?.errorCode ?? "install_failed",
+        userTitle: installError?.userTitle ?? "Update failed",
+        userMessage: installError?.message ?? message,
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      currentVersion: this.snapshot.latestVersion ?? this.snapshot.currentVersion,
+      status: "restart_pending",
+      updateAvailable: false,
+      error: null,
+      reloadRequestedAt: Date.now(),
+    })
+    this.deps.trackEvent?.("update_installed", {
+      latest_version: this.snapshot.latestVersion,
+    })
+    return { ok: true, action: "restart", errorCode: null, userTitle: null, userMessage: null }
+  }
+
+  private setSnapshot(snapshot: UpdateSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) listener(snapshot)
+  }
+}

package/src/server/update-strategy.test.ts

@@ -0,0 +1,237 @@
+import { describe, expect, test } from "bun:test"
+import { NpmChecker, SupervisorExitReloader, UpdateInstallError, createUpdateStrategy, GitChecker, Pm2Reloader } from "./update-strategy"
+
+describe("NpmChecker", () => {
+  test("reports update available when latest is newer", async () => {
+    const checker = new NpmChecker({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "0.13.0",
+    })
+    const result = await checker.check()
+    expect(result).toEqual({ latestVersion: "0.13.0", updateAvailable: true })
+  })
+
+  test("reports no update when versions match", async () => {
+    const checker = new NpmChecker({
+      currentVersion: "0.13.0",
+      fetchLatestVersion: async () => "0.13.0",
+    })
+    const result = await checker.check()
+    expect(result).toEqual({ latestVersion: "0.13.0", updateAvailable: false })
+  })
+
+  test("propagates fetch errors", async () => {
+    const checker = new NpmChecker({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => { throw new Error("registry down") },
+    })
+    await expect(checker.check()).rejects.toThrow("registry down")
+  })
+})
+
+describe("SupervisorExitReloader", () => {
+  test("installs target version when invoked", async () => {
+    const calls: Array<{ packageName: string; version: string }> = []
+    const reloader = new SupervisorExitReloader({
+      targetVersion: () => "0.13.0",
+      installVersion: (packageName, version) => {
+        calls.push({ packageName, version })
+        return { ok: true, errorCode: null, userTitle: null, userMessage: null }
+      },
+    })
+    await reloader.reload()
+    expect(calls).toEqual([{ packageName: "@cuongtran001/kanna", version: "0.13.0" }])
+  })
+
+  test("throws UpdateInstallError with structured fields when install fails", async () => {
+    const reloader = new SupervisorExitReloader({
+      targetVersion: () => "0.13.0",
+      installVersion: () => ({
+        ok: false,
+        errorCode: "version_not_live_yet",
+        userTitle: "Update not live yet",
+        userMessage: "This update is still propagating. Try again in a few minutes.",
+      }),
+    })
+    await expect(reloader.reload()).rejects.toBeInstanceOf(UpdateInstallError)
+    await expect(reloader.reload()).rejects.toMatchObject({
+      message: "This update is still propagating. Try again in a few minutes.",
+      errorCode: "version_not_live_yet",
+      userTitle: "Update not live yet",
+    })
+  })
+
+  test("throws when target version cannot be resolved", async () => {
+    const reloader = new SupervisorExitReloader({
+      targetVersion: () => null,
+      installVersion: () => ({ ok: true, errorCode: null, userTitle: null, userMessage: null }),
+    })
+    await expect(reloader.reload()).rejects.toThrow(/target version/i)
+  })
+})
+
+describe("GitChecker", () => {
+  const makeRunGit = (responses: Record<string, string>) => async (args: string[]) => {
+    const key = args.join(" ")
+    if (!(key in responses)) throw new Error(`unexpected git call: ${key}`)
+    return responses[key]
+  }
+
+  test("reports update when HEAD differs from upstream", async () => {
+    const checker = new GitChecker({
+      repoDir: "/tmp/repo",
+      branch: "main",
+      runGit: makeRunGit({
+        "fetch origin main": "",
+        "rev-parse HEAD": "abc123def456\n",
+        "rev-parse origin/main": "deadbeef99887\n",
+      }),
+    })
+    const result = await checker.check()
+    expect(result).toEqual({ latestVersion: "deadbee", updateAvailable: true })
+  })
+
+  test("reports no update when HEAD matches upstream", async () => {
+    const checker = new GitChecker({
+      repoDir: "/tmp/repo",
+      branch: "main",
+      runGit: makeRunGit({
+        "fetch origin main": "",
+        "rev-parse HEAD": "abc123def456\n",
+        "rev-parse origin/main": "abc123def456\n",
+      }),
+    })
+    const result = await checker.check()
+    expect(result).toEqual({ latestVersion: "abc123d", updateAvailable: false })
+  })
+
+  test("propagates git fetch errors", async () => {
+    const checker = new GitChecker({
+      repoDir: "/tmp/repo",
+      branch: "main",
+      runGit: async () => { throw new Error("fetch failed: network") },
+    })
+    await expect(checker.check()).rejects.toThrow(/fetch failed/)
+  })
+})
+
+describe("createUpdateStrategy", () => {
+  const baseDeps = {
+    currentVersion: "0.12.0",
+    fetchLatestVersion: async () => "0.13.0",
+    installVersion: () => ({ ok: true, errorCode: null, userTitle: null, userMessage: null }),
+    latestVersionHint: () => "0.13.0",
+  } as const
+
+  test("defaults to npm + supervisor-exit when env unset", () => {
+    const strategy = createUpdateStrategy({ reloaderEnv: undefined, ...baseDeps })
+    expect(strategy.checker).toBeInstanceOf(NpmChecker)
+    expect(strategy.reloader).toBeInstanceOf(SupervisorExitReloader)
+  })
+
+  test("uses npm + supervisor-exit when env=supervisor", () => {
+    const strategy = createUpdateStrategy({ reloaderEnv: "supervisor", ...baseDeps })
+    expect(strategy.checker).toBeInstanceOf(NpmChecker)
+    expect(strategy.reloader).toBeInstanceOf(SupervisorExitReloader)
+  })
+
+  test("throws on unknown reloader value", () => {
+    expect(() => createUpdateStrategy({ reloaderEnv: "bogus", ...baseDeps })).toThrow(/unknown.*reloader/i)
+  })
+})
+
+describe("Pm2Reloader", () => {
+  function makeReloader(overrides: {
+    lockfileChanged?: boolean
+    commandErrors?: Record<string, string>
+    reloadError?: Error | null
+  } = {}) {
+    const calls: string[] = []
+    const reloader = new Pm2Reloader({
+      repoDir: "/tmp/repo",
+      processName: "kanna",
+      runCommand: async (command, args) => {
+        const line = [command, ...args].join(" ")
+        calls.push(line)
+        if (overrides.commandErrors?.[line]) {
+          throw new Error(overrides.commandErrors[line])
+        }
+      },
+      lockfileChanged: async () => overrides.lockfileChanged ?? false,
+      triggerPm2Reload: async () => {
+        calls.push("pm2.reload kanna")
+        if (overrides.reloadError) throw overrides.reloadError
+      },
+    })
+    return { reloader, calls }
+  }
+
+  test("runs git pull, build, then pm2 reload when lockfile unchanged", async () => {
+    const { reloader, calls } = makeReloader({ lockfileChanged: false })
+    await reloader.reload()
+    expect(calls).toEqual([
+      "git pull --ff-only",
+      "bun run build",
+      "pm2.reload kanna",
+    ])
+  })
+
+  test("inserts bun install when lockfile changed", async () => {
+    const { reloader, calls } = makeReloader({ lockfileChanged: true })
+    await reloader.reload()
+    expect(calls).toEqual([
+      "git pull --ff-only",
+      "bun install",
+      "bun run build",
+      "pm2.reload kanna",
+    ])
+  })
+
+  test("aborts before reload when git pull fails", async () => {
+    const { reloader, calls } = makeReloader({
+      commandErrors: { "git pull --ff-only": "merge conflict in src/foo.ts" },
+    })
+    await expect(reloader.reload()).rejects.toThrow(/git pull failed/i)
+    expect(calls).toEqual(["git pull --ff-only"])
+  })
+
+  test("aborts before reload when build fails", async () => {
+    const { reloader, calls } = makeReloader({
+      commandErrors: { "bun run build": "tsc error TS2345" },
+    })
+    await expect(reloader.reload()).rejects.toThrow(/bun run build failed/i)
+    expect(calls).toEqual(["git pull --ff-only", "bun run build"])
+  })
+
+  test("surfaces pm2 reload failures", async () => {
+    const { reloader } = makeReloader({ reloadError: new Error("pm2 daemon not running") })
+    await expect(reloader.reload()).rejects.toThrow(/pm2 reload failed/i)
+  })
+})
+
+describe("createUpdateStrategy pm2 branch", () => {
+  test("returns GitChecker + Pm2Reloader for KANNA_RELOADER=pm2", () => {
+    const strategy = createUpdateStrategy({
+      reloaderEnv: "pm2",
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "ignored",
+      installVersion: () => ({ ok: true, errorCode: null, userTitle: null, userMessage: null }),
+      latestVersionHint: () => null,
+      repoDir: "/tmp/repo",
+    })
+    expect(strategy.checker).toBeInstanceOf(GitChecker)
+    expect(strategy.reloader).toBeInstanceOf(Pm2Reloader)
+  })
+
+  test("throws when pm2 mode selected without repoDir", () => {
+    expect(() =>
+      createUpdateStrategy({
+        reloaderEnv: "pm2",
+        currentVersion: "0.12.0",
+        fetchLatestVersion: async () => "ignored",
+        installVersion: () => ({ ok: true, errorCode: null, userTitle: null, userMessage: null }),
+        latestVersionHint: () => null,
+      }),
+    ).toThrow(/KANNA_REPO_DIR/)
+  })
+})