@kimchi-dev/kimchictl 0.0.2

package/src/ssh/connect.test.ts

@@ -0,0 +1,123 @@
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { cleanupTempDirs, jsonResponse, makeTempDir, stubFetch } from "../test-support.js"
+import { connectToWorkspace } from "./connect.js"
+
+beforeEach(() => {
+	const home = makeTempDir()
+	vi.stubEnv("HOME", home)
+	vi.stubEnv("KIMCHICTL_HOME", join(home, ".kimchictl"))
+	vi.stubEnv("KIMCHI_API_KEY", "key-1")
+	vi.spyOn(console, "error").mockImplementation(() => {})
+})
+
+afterEach(() => {
+	cleanupTempDirs()
+	vi.unstubAllEnvs()
+	vi.restoreAllMocks()
+})
+
+const UUID = "3d3dc322-dd05-4d0c-adab-beb2a0819e69"
+
+function wsJson(status: string): Record<string, unknown> {
+	return {
+		id: UUID,
+		description: "",
+		status,
+		createTime: "2026-01-01T12:00:00Z",
+		uri: "ws-1.remote.kimchi.dev",
+		spec: { resources: { cpu: "500m", memory: "1Gi" } },
+	}
+}
+
+function makeFetch(options?: { suspendedFirst?: boolean }): { fetch: typeof globalThis.fetch; calls: string[] } {
+	const calls: string[] = []
+	let resumed = false
+	const suspendedFirst = options?.suspendedFirst === true
+	const fetch = stubFetch(async (url) => {
+		calls.push(url)
+		if (url.endsWith("/workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
+		if (url.includes("?page.limit=")) {
+			// The list snapshot decides the initial status.
+			return jsonResponse({ items: [wsJson(suspendedFirst && !resumed ? "SUSPENDED" : "ACTIVE")] })
+		}
+		if (url.endsWith(`/${UUID}`)) {
+			// Read-through polls (post-resume wait) see the current state.
+			return jsonResponse(wsJson(resumed || !suspendedFirst ? "ACTIVE" : "SUSPENDED"))
+		}
+		if (url.endsWith(`/${UUID}:resume`)) {
+			resumed = true
+			return jsonResponse({})
+		}
+		throw new Error(`unexpected request: ${url}`)
+	})
+	return { fetch, calls }
+}
+
+describe("connectToWorkspace", () => {
+	it("execs ssh to <alias>.<domain> with the remote command, no resume when ACTIVE", async () => {
+		const { fetch, calls } = makeFetch()
+		const execArgs: string[][] = []
+
+		const code = await connectToWorkspace("ws-1", ["uptime"], {
+			fetch,
+			exec: (args) => {
+				execArgs.push(args)
+				return 0
+			},
+		})
+
+		expect(code).toBe(0)
+		expect(execArgs).toEqual([["ssh", "ws-1.remote.kimchi.dev", "uptime"]])
+		expect(calls.some((c) => c.endsWith(":resume"))).toBe(false)
+	})
+
+	it("accepts a full hostname and still connects by alias", async () => {
+		const { fetch } = makeFetch()
+		const execArgs: string[][] = []
+
+		await connectToWorkspace("ws-1.remote.kimchi.dev", [], {
+			fetch,
+			exec: (args) => {
+				execArgs.push(args)
+				return 0
+			},
+		})
+
+		expect(execArgs).toEqual([["ssh", "ws-1.remote.kimchi.dev"]])
+	})
+
+	it("auto-configures SSH integration on first use", async () => {
+		const { fetch } = makeFetch()
+		await connectToWorkspace("ws-1", [], { fetch, exec: () => 0 })
+
+		expect(existsSync(join(process.env.KIMCHICTL_HOME ?? "", "ssh_config"))).toBe(true)
+	})
+
+	it("skips auto-setup when KIMCHICTL_NO_SSH_SETUP is set", async () => {
+		vi.stubEnv("KIMCHICTL_NO_SSH_SETUP", "1")
+		const { fetch } = makeFetch()
+		await connectToWorkspace("ws-1", [], { fetch, exec: () => 0 })
+
+		expect(existsSync(join(process.env.KIMCHICTL_HOME ?? "", "ssh_config"))).toBe(false)
+	})
+
+	it("resumes a suspended workspace, waits for ACTIVE, then connects", async () => {
+		const { fetch, calls } = makeFetch({ suspendedFirst: true })
+		const execArgs: string[][] = []
+
+		const code = await connectToWorkspace("ws-1", [], {
+			fetch,
+			sleep: async () => {},
+			exec: (args) => {
+				execArgs.push(args)
+				return 0
+			},
+		})
+
+		expect(code).toBe(0)
+		expect(calls.some((c) => c.endsWith(":resume"))).toBe(true)
+		expect(execArgs.length).toBe(1)
+	})
+})

package/src/ssh/connect.ts

@@ -0,0 +1,98 @@
+import { spawnSync } from "node:child_process"
+import { resolveWorkspace } from "../api/resolver.js"
+import type { ApiOptions } from "../api/types.js"
+import { waitForWorkspaceActive } from "../api/wait.js"
+import { requireApiKey } from "../auth/resolve.js"
+import {
+	isSshIntegrationConfigured,
+	isSshSetupDisabled,
+	resolveSshDomain,
+	resolveSshPaths,
+	setupSshIntegration,
+} from "./config.js"
+import { resumeForConnect, workspaceIdFromRef } from "./tunnel.js"
+
+/** Post-resume wait budget for a hibernated workspace to reach ACTIVE. */
+const RESUME_WAIT_TIMEOUT_MS = 90_000
+
+/**
+ * Validate that native SSH integration is configured; set it up automatically
+ * when missing (the "setup on use" half of the setup-on-install decision).
+ * Returns false when auto-setup is disabled via KIMCHICTL_NO_SSH_SETUP.
+ */
+export async function ensureSshIntegration(options: {
+	env?: NodeJS.ProcessEnv
+	domain?: string
+	/** Injection seams for tests. */
+	setup?: typeof setupSshIntegration
+	isConfigured?: typeof isSshIntegrationConfigured
+}): Promise<boolean> {
+	const env = options.env ?? process.env
+	if (isSshSetupDisabled(env)) return false
+
+	const paths = resolveSshPaths(env)
+	const domain = resolveSshDomain(options.domain, env)
+	const isConfigured = options.isConfigured ?? isSshIntegrationConfigured
+	if (await isConfigured(paths, domain)) return true
+
+	const setup = options.setup ?? setupSshIntegration
+	const { notes } = await setup({ paths, domain })
+	console.error("✓ SSH integration configured")
+	for (const note of notes) console.error(`  ${note}`)
+	console.error("  undo: kimchictl ssh setup --uninstall")
+	return true
+}
+
+export interface SshConnectOptions extends ApiOptions {
+	env?: NodeJS.ProcessEnv
+	/** Exec seam (tests): run system ssh, return its exit status. */
+	exec?: (args: string[]) => number
+	sleep?: (ms: number) => Promise<void>
+}
+
+function defaultExec(args: string[]): number {
+	return spawnSync(args[0] ?? "ssh", args.slice(1), { stdio: "inherit", shell: false }).status ?? 1
+}
+
+/**
+ * Connect to a workspace with system ssh: ensure integration → resume a
+ * hibernated workspace (and wait for it) → exec `ssh <alias>.<domain>` with
+ * inherited stdio. Extra args are passed to ssh as the remote command.
+ */
+export async function connectToWorkspace(
+	name: string,
+	remoteCommand: string[],
+	options: SshConnectOptions = {},
+): Promise<number> {
+	const env = options.env ?? process.env
+	await ensureSshIntegration({ env })
+
+	const { key } = requireApiKey(env)
+
+	// Accepts "<alias>", "<alias>.<domain>", a UUID, or an alias prefix.
+	const ref = workspaceIdFromRef(name)
+	let workspace = await resolveWorkspace(key, ref, options)
+	if (workspace.status === "suspended" || workspace.status === "initializing") {
+		if (workspace.status === "suspended") {
+			await resumeForConnect(key, workspace.id, options)
+		}
+		process.stderr.write("  resuming…")
+		workspace = await waitForWorkspaceActive(key, workspace.id, {
+			...options,
+			timeoutMs: RESUME_WAIT_TIMEOUT_MS,
+			sleep: options.sleep,
+			onTick: (elapsedSeconds) => process.stderr.write(`\r  resuming… ${elapsedSeconds}s`),
+		})
+		process.stderr.write("\n")
+		if (workspace.status !== "active") {
+			process.stderr.write(
+				`  ⚠ workspace is ${workspace.status} — connecting anyway; ` +
+					`if it fails, retry in a minute or check: kimchictl workspace get ${workspace.alias}\n`,
+			)
+		}
+	}
+
+	const domain = resolveSshDomain(undefined, env)
+	const host = `${workspace.alias}.${domain}`
+	return (options.exec ?? defaultExec)(["ssh", host, ...remoteCommand])
+}

package/src/ssh/tunnel.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { jsonResponse, stubFetch } from "../test-support.js"
+import { buildWsUrl, resolveTunnel, resumeForConnect, workspaceIdFromRef } from "./tunnel.js"
+
+afterEach(() => {
+	vi.unstubAllEnvs()
+})
+
+const UUID = "3d3dc322-dd05-4d0c-adab-beb2a0819e69"
+
+const WS_JSON = {
+	id: UUID,
+	description: "",
+	status: "ACTIVE",
+	createTime: "2026-01-01T12:00:00Z",
+	uri: "ws-1.remote.kimchi.dev",
+	spec: { resources: { cpu: "500m", memory: "1Gi" } },
+}
+
+interface Call {
+	url: string
+	init?: RequestInit
+}
+
+describe("workspaceIdFromRef", () => {
+	it("keeps bare refs and strips a domain suffix", () => {
+		expect(workspaceIdFromRef("ws-1")).toBe("ws-1")
+		expect(workspaceIdFromRef("ws-1.remote.kimchi.dev")).toBe("ws-1")
+	})
+})
+
+describe("buildWsUrl", () => {
+	it("builds wss://<host>/ssh, no port suffix for 443", () => {
+		expect(buildWsUrl("ws-1.remote.kimchi.dev")).toBe("wss://ws-1.remote.kimchi.dev/ssh")
+		expect(buildWsUrl("wss://ws-1.remote.kimchi.dev/ws/ssh-proxy")).toBe("wss://ws-1.remote.kimchi.dev/ssh")
+	})
+
+	it("appends a non-443 port", () => {
+		expect(buildWsUrl("ws-1.remote.kimchi.dev", 8443)).toBe("wss://ws-1.remote.kimchi.dev:8443/ssh")
+	})
+})
+
+describe("resolveTunnel", () => {
+	it("resolves the alias via the workspace list, exchanges a token for the UUID, and assembles the WS URL", async () => {
+		const calls: Call[] = []
+		const fetch = stubFetch(async (url, init) => {
+			calls.push({ url, init })
+			if (url.endsWith("/workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
+			if (url.includes("?page.limit=")) return jsonResponse({ items: [WS_JSON] })
+			if (url.endsWith("/workspace-tokens:exchange")) {
+				return jsonResponse({ token: "ws-jwt-1", expireTime: "2026-01-01T01:00:00Z" })
+			}
+			throw new Error(`unexpected request: ${url}`)
+		})
+
+		const creds = await resolveTunnel("key-1", "ws-1.remote.kimchi.dev", { fetch })
+
+		expect(creds).toEqual({ wsUrl: "wss://ws-1.remote.kimchi.dev/ssh", token: "ws-jwt-1" })
+		const exchange = calls.find((c) => c.url.endsWith(":exchange"))
+		expect(JSON.parse(String(exchange?.init?.body))).toEqual({ workspaceId: UUID })
+	})
+
+	it("goes straight to GET for a UUID ref", async () => {
+		const fetch = stubFetch(async (url) => {
+			if (url.endsWith("/workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
+			if (url.endsWith(`/workspaces/${UUID}`)) return jsonResponse(WS_JSON)
+			if (url.endsWith("/workspace-tokens:exchange")) return jsonResponse({ token: "ws-jwt-1" })
+			throw new Error(`unexpected request: ${url}`)
+		})
+
+		const creds = await resolveTunnel("key-1", UUID, { fetch })
+
+		expect(creds).toEqual({ wsUrl: "wss://ws-1.remote.kimchi.dev/ssh", token: "ws-jwt-1" })
+	})
+
+	it("surfaces when the workspace has no URI yet", async () => {
+		// An alias cannot exist without a URI (alias falls back to the id), so the
+		// no-URI state is reachable via a UUID ref to a still-provisioning workspace.
+		const fetch = stubFetch(async (url) => {
+			if (url.endsWith("/workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
+			if (url.endsWith(`/workspaces/${UUID}`)) {
+				return jsonResponse({ ...WS_JSON, status: "INITIALIZING", uri: "" })
+			}
+			throw new Error(`unexpected request: ${url}`)
+		})
+
+		await expect(resolveTunnel("key-1", UUID, { fetch })).rejects.toMatchObject({
+			message: expect.stringContaining("no connection URI"),
+		})
+	})
+})
+
+describe("resumeForConnect", () => {
+	it("POSTs resume with the api key", async () => {
+		const calls: Call[] = []
+		const fetch = stubFetch(async (url, init) => {
+			calls.push({ url, init })
+			if (url.endsWith("/workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
+			if (url.endsWith(`/workspaces/${UUID}:resume`)) return jsonResponse({})
+			throw new Error(`unexpected request: ${url}`)
+		})
+
+		await resumeForConnect("key-1", UUID, { fetch })
+
+		const resume = calls.find((c) => c.url.endsWith(":resume"))
+		expect(resume?.init?.method).toBe("POST")
+		expect(resume?.init?.headers).toMatchObject({ Authorization: "Bearer key-1" })
+	})
+
+	it("tolerates 'not suspended' 400s (already running)", async () => {
+		const fetch = stubFetch(async (url) => {
+			if (url.endsWith("/workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
+			if (url.endsWith(`/workspaces/${UUID}:resume`)) return new Response("workspace is not suspended", { status: 400 })
+			throw new Error(`unexpected request: ${url}`)
+		})
+
+		await expect(resumeForConnect("key-1", UUID, { fetch })).resolves.toBeUndefined()
+	})
+})

package/src/ssh/tunnel.ts

@@ -0,0 +1,64 @@
+import { verifyApiKey } from "../api/keys.js"
+import { resolveWorkspace } from "../api/resolver.js"
+import { exchangeWorkspaceToken, resumeWorkspace } from "../api/tokens.js"
+import type { ApiOptions } from "../api/types.js"
+import { RemoteNetworkError } from "../api/types.js"
+
+/**
+ * Tunnel resolution for the SSH bridge (TS port of kap's
+ * internal/ssh/bridge.go ResolveTunnel — refs resolve via api/resolver.ts).
+ */
+
+export interface TunnelCreds {
+	/** wss://<workspace-host>/ssh */
+	wsUrl: string
+	/** Short-lived workspace JWT for the Authorization header. */
+	token: string
+}
+
+/**
+ * Accepts a bare workspace id or a full hostname (id.domain) — the domain
+ * suffix is stripped, which is what makes this usable as the ProxyCommand
+ * target (`%h` expands to the full hostname).
+ */
+export function workspaceIdFromRef(wsRef: string): string {
+	const dot = wsRef.indexOf(".")
+	return dot > 0 ? wsRef.slice(0, dot) : wsRef
+}
+
+/** wss://{uri}/ssh — explicit port appended only when not 0/443 (kap parity). */
+export function buildWsUrl(uri: string, port = 443): string {
+	// The API may return a bare host or a scheme-prefixed URI; normalize to host[:port].
+	const host = uri.includes("://") ? new URL(uri).host : uri
+	if (!host) throw new RemoteNetworkError(`Invalid workspace URI from server: ${uri}`)
+	return `wss://${host}${port === 0 || port === 443 ? "" : `:${port}`}/ssh`
+}
+
+export interface ResolveTunnelOptions extends ApiOptions {
+	/** WebSocket port override (dev; default 443). */
+	port?: number
+}
+
+export async function resolveTunnel(
+	apiKey: string,
+	wsRef: string,
+	options?: ResolveTunnelOptions,
+): Promise<TunnelCreds> {
+	const ref = workspaceIdFromRef(wsRef)
+	const workspace = await resolveWorkspace(apiKey, ref, options)
+	if (!workspace.uri) {
+		throw new RemoteNetworkError(`Workspace ${ref} has no connection URI yet — it may still be provisioning`)
+	}
+	const { token } = await exchangeWorkspaceToken(apiKey, workspace.id, options)
+	return { wsUrl: buildWsUrl(workspace.uri, options?.port), token }
+}
+
+/** Wake a hibernated workspace. Best-effort by contract: resume is idempotent server-side. */
+export async function resumeForConnect(
+	apiKey: string,
+	workspaceId: string,
+	options?: ApiOptions & { orgId?: string },
+): Promise<void> {
+	const orgId = options?.orgId ?? (await verifyApiKey(apiKey, options))
+	await resumeWorkspace(apiKey, workspaceId, { ...options, orgId })
+}

package/src/test-support.ts

@@ -0,0 +1,77 @@
+/**
+ * Shared test helpers — co-located *.test.ts files import from here instead of
+ * re-rolling temp-dir / fetch-stub / console-capture boilerplate per file.
+ * Excluded from the published build (tsconfig.build.json).
+ */
+
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, join } from "node:path"
+import { vi } from "vitest"
+
+const tempDirs: string[] = []
+
+export function makeTempDir(prefix = "kimchictl-test-"): string {
+	const dir = mkdtempSync(join(tmpdir(), prefix))
+	tempDirs.push(dir)
+	return dir
+}
+
+/** Call from afterEach — removes every dir created via makeTempDir. */
+export function cleanupTempDirs(): void {
+	for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true })
+}
+
+export type FetchImpl = typeof globalThis.fetch
+
+/**
+ * Build a fetch stub from a narrow implementation. The `as unknown` adapts the
+ * test's string-URL signature to fetch's wide `(string | URL | Request)` one —
+ * deliberate, one place, test-only.
+ */
+export function stubFetch(impl: (url: string, init?: RequestInit) => Promise<Response>): FetchImpl {
+	return impl as unknown as FetchImpl
+}
+
+export function jsonResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" },
+	})
+}
+
+/** Point the shared-credential paths at an isolated HOME + agent dir and neutralize ambient key env vars. Returns the stubbed HOME — the shared config.json lives at `<home>/.config/kimchi/config.json` (sibling of the harness agent dir, matching kimchi-dev:src/config.ts). */
+export function stubAgentDirEnv(dir: string): { home: string } {
+	const home = makeTempDir()
+	vi.stubEnv("HOME", home)
+	vi.stubEnv("KIMCHI_CODING_AGENT_DIR", dir)
+	// resolveApiKey treats an empty KIMCHI_API_KEY as absent.
+	vi.stubEnv("KIMCHI_API_KEY", "")
+	return { home }
+}
+
+/** Path of the harness's shared wizard config under a (stubbed) HOME. */
+export function sharedConfigPath(home: string): string {
+	return join(home, ".config", "kimchi", "config.json")
+}
+
+/** Seed the shared config.json under a stubbed HOME (creates parent dirs). */
+export function writeSharedConfigJson(home: string, value: unknown): string {
+	const configPath = sharedConfigPath(home)
+	mkdirSync(dirname(configPath), { recursive: true })
+	writeFileSync(configPath, JSON.stringify(value, null, 2))
+	return configPath
+}
+
+/** Capture console.log / console.error; restore() in afterEach (or rely on vi.restoreAllMocks). */
+export function captureConsole(): { lines: string[]; errors: string[] } {
+	const lines: string[] = []
+	const errors: string[] = []
+	vi.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+		lines.push(args.map(String).join(" "))
+	})
+	vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => {
+		errors.push(args.map(String).join(" "))
+	})
+	return { lines, errors }
+}

package/src/updates/check.test.ts

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import { cleanupTempDirs, jsonResponse, makeTempDir, stubFetch } from "../test-support.js"
+import { checkForUpdate, isNewer } from "./check.js"
+
+beforeEach(() => {
+	const home = makeTempDir()
+	vi.stubEnv("HOME", home)
+	vi.stubEnv("KIMCHICTL_HOME", join(home, ".kimchictl"))
+	vi.stubEnv("KIMCHICTL_NO_UPDATE_CHECK", "")
+})
+
+afterEach(() => {
+	cleanupTempDirs()
+	vi.unstubAllEnvs()
+})
+
+describe("isNewer", () => {
+	it("compares semver-ish strings numerically", () => {
+		expect(isNewer("0.2.0", "0.10.0")).toBe(false)
+		expect(isNewer("0.10.0", "0.2.0")).toBe(true)
+		expect(isNewer("1.0.0", "1.0.0")).toBe(false)
+		expect(isNewer("v0.3.0", "0.2.9")).toBe(true)
+	})
+})
+
+describe("checkForUpdate", () => {
+	it("is silent for dev builds", async () => {
+		const fetch = stubFetch(async () => {
+			throw new Error("should not fetch")
+		})
+		expect(await checkForUpdate({ fetch, currentVersion: "0.0.0-dev" })).toBeUndefined()
+	})
+
+	it("respects the escape-hatch env var", async () => {
+		vi.stubEnv("KIMCHICTL_NO_UPDATE_CHECK", "1")
+		const result = await checkForUpdate({
+			currentVersion: "0.1.0",
+			fetch: stubFetch(async () => {
+				throw new Error("should not fetch")
+			}),
+		})
+		expect(result).toBeUndefined()
+	})
+
+	it("fetches once a day, notifies only when newer, and caches", async () => {
+		let fetches = 0
+		const fetch = stubFetch(async (url) => {
+			fetches++
+			expect(url).toContain("/releases/latest")
+			return jsonResponse({ tag_name: "0.3.0" })
+		})
+		const now = () => new Date("2026-02-01T00:00:00Z")
+
+		const first = await checkForUpdate({ fetch, now, currentVersion: "0.2.0" })
+		expect(first).toEqual({ latest: "0.3.0", current: "0.2.0" })
+
+		// Fresh cache — no refetch.
+		const second = await checkForUpdate({ fetch, now, currentVersion: "0.2.0" })
+		expect(second).toEqual({ latest: "0.3.0", current: "0.2.0" })
+		expect(fetches).toBe(1)
+
+		const cachePath = join(process.env.KIMCHICTL_HOME ?? "", "update-check.json")
+		expect(existsSync(cachePath)).toBe(true)
+		expect(JSON.parse(readFileSync(cachePath, "utf-8"))).toEqual({
+			latestVersion: "0.3.0",
+			checkedAt: "2026-02-01T00:00:00.000Z",
+		})
+
+		// Not newer → quiet.
+		const upToDate = await checkForUpdate({ fetch, now, currentVersion: "0.3.0" })
+		expect(upToDate).toBeUndefined()
+	})
+
+	it("refetches when the cache is stale", async () => {
+		let fetches = 0
+		const fetch = stubFetch(async () => {
+			fetches++
+			return jsonResponse({ tag_name: "0.3.0" })
+		})
+		const day1 = () => new Date("2026-02-01T00:00:00Z")
+		const day2 = () => new Date("2026-02-03T12:00:00Z") // >24h later
+
+		await checkForUpdate({ fetch, now: day1, currentVersion: "0.2.0" })
+		await checkForUpdate({ fetch, now: day2, currentVersion: "0.2.0" })
+		expect(fetches).toBe(2)
+	})
+
+	it("never throws on network failure or malformed responses", async () => {
+		const failing = stubFetch(async () => {
+			throw new Error("offline")
+		})
+		expect(await checkForUpdate({ fetch: failing, currentVersion: "0.2.0" })).toBeUndefined()
+
+		const weird = stubFetch(async () => jsonResponse({ nope: true }))
+		expect(await checkForUpdate({ fetch: weird, currentVersion: "0.2.0" })).toBeUndefined()
+	})
+})