import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../config/config.js";

import { resolveChannelAllowFromPath } from "../pairing/pairing-store.js";

import { openOpenClawStateDatabase } from "../state/openclaw-state-db.js";

import type { DB as OpenClawStateKyselyDatabase } from "../state/openclaw-state-db.generated.js";

import {

closeOpenClawStateDatabaseForTest,

openOpenClawStateDatabase,

} from "../state/openclaw-state-db.js";

import { createTrackedTempDirs } from "../test-utils/tracked-temp-dirs.js";

import { executeSqliteQueryTakeFirstSync, getNodeSqliteKysely } from "./kysely-sync.js";

import {

autoMigrateLegacyState,

detectLegacyStateMigrations,

const tempDirs = createTrackedTempDirs();

type UpdateCheckStateDatabase = Pick<OpenClawStateKyselyDatabase, "update_check_state">;

async function expectMissingPath(targetPath: string): Promise<void> {

let statError: NodeJS.ErrnoException | undefined;

try {

}

const createTempDir = () => tempDirs.make("openclaw-state-migrations-test-");

function readUpdateCheckState(env: NodeJS.ProcessEnv):

| {

last_checked_at: string | null;

last_available_version: string | null;

last_available_tag: string | null;

auto_install_id: string | null;

}

| undefined {

const { db } = openOpenClawStateDatabase({ env });

const stateDb = getNodeSqliteKysely<UpdateCheckStateDatabase>(db);

return executeSqliteQueryTakeFirstSync(

db,

stateDb

.selectFrom("update_check_state")

.select([

"last_checked_at",

"last_available_version",

"last_available_tag",

"auto_install_id",

])

.where("state_key", "=", "default"),

);

}

function createConfig(): OpenClawConfig {

return {

agents: {

afterEach(async () => {

vi.useRealTimers();

closeOpenClawStateDatabaseForTest();

await tempDirs.cleanup();

});

await expectMissingPath(path.join(settingsDir, "voicewake.json"));

});

it("migrates legacy update-check JSON into shared SQLite state", async () => {

const root = await createTempDir();

const stateDir = path.join(root, ".openclaw");

const env = createEnv(stateDir);

const cfg = createConfig();

const sourcePath = path.join(stateDir, "update-check.json");

await fs.mkdir(stateDir, { recursive: true });

await fs.writeFile(

sourcePath,

JSON.stringify({

lastCheckedAt: "2026-01-17T09:30:00.000Z",

lastAvailableVersion: "2.0.0",

lastAvailableTag: "latest",

autoInstallId: "install-1",

}),

"utf8",

);

const detected = await detectLegacyStateMigrations({ cfg, env, homedir: () => root });

expect(detected.updateCheck.hasLegacy).toBe(true);

expect(detected.preview).toContain(

"- Update-check state: legacy JSON file → shared SQLite state",

);

const result = await runLegacyStateMigrations({ detected, config: cfg });

expect(result.warnings).toStrictEqual([]);

expect(result.changes).toContain("Migrated update-check state → shared SQLite state");

expect(readUpdateCheckState(env)).toMatchObject({

last_checked_at: "2026-01-17T09:30:00.000Z",

last_available_version: "2.0.0",

last_available_tag: "latest",

auto_install_id: "install-1",

});

await expectMissingPath(sourcePath);

await expect(fs.readFile(`${sourcePath}.migrated`, "utf8")).resolves.toContain("2.0.0");

});

it("keeps legacy delivery queue files when shared SQLite already has a conflicting row", async () => {

const root = await createTempDir();

const stateDir = path.join(root, ".openclaw");