[Fix] Recover conversation migration state safely

packages/core/src/middlewares/system/conversation_manage.ts

@@ -45,6 +45,7 @@ export function apply(ctx: Context, config: Config, chain: ChatChain) {
 
         if (
             resolved.constraint.manageMode === 'admin' &&
+            resolved.constraint.routeMode !== 'personal' &&
             !(await checkAdmin(session))
         ) {
             context.message = session.text(

packages/core/src/middlewares/system/wipe.ts

@@ -5,6 +5,7 @@ import { createLogger } from 'koishi-plugin-chatluna/utils/logger'
 import fs from 'fs/promises'
 import {
     createLegacyTableRetention,
+    createPassedValidationResult,
     dropTableIfExists,
     getLegacySchemaSentinel,
     getLegacySchemaSentinelDir,
@@ -15,6 +16,7 @@ import {
     readMetaValue,
     writeMetaValue
 } from '../../migration/validators'
+import { BUILTIN_SCHEMA_VERSION } from '../../migration/room_to_conversation'
 
 let logger: Logger
 
@@ -76,12 +78,13 @@ export function apply(ctx: Context, _config: Config, chain: ChatChain) {
             'chatluna_binding',
             'chatluna_constraint',
             'chatluna_archive',
-            'chatluna_acl',
-            'chatluna_meta'
+            'chatluna_acl'
         ]) {
             await dropTableIfExists(ctx, table)
         }
 
+        await ctx.database.remove('chatluna_meta', {})
+
         for (const table of LEGACY_MIGRATION_TABLES) {
             await dropTableIfExists(ctx, table)
         }
@@ -115,6 +118,22 @@ export function apply(ctx: Context, _config: Config, chain: ChatChain) {
             logger.warn(`wipe: ${e}`)
         }
 
+        const validated = createPassedValidationResult()
+        await writeMetaValue(ctx, 'schema_version', BUILTIN_SCHEMA_VERSION)
+        await writeMetaValue(ctx, 'validation_result', validated)
+        await writeMetaValue(ctx, 'room_migration_done', true)
+        await writeMetaValue(ctx, 'message_migration_done', true)
+        await writeMetaValue(
+            ctx,
+            LEGACY_RETENTION_META_KEY,
+            createLegacyTableRetention('purged')
+        )
+        await writeMetaValue(
+            ctx,
+            'migration_finished_at',
+            new Date().toISOString()
+        )
+
         const sentinelDir = getLegacySchemaSentinelDir(ctx.baseDir)
         const sentinelPath = getLegacySchemaSentinel(ctx.baseDir)
         await fs.mkdir(sentinelDir, { recursive: true })

packages/core/src/migration/legacy_tables.ts

@@ -39,8 +39,8 @@ export function getLegacySchemaSentinelDir(baseDir: string) {
     return path.dirname(getLegacySchemaSentinel(baseDir))
 }
 
-export function defineLegacyMigrationTables(ctx: Context) {
-    if (existsSync(getLegacySchemaSentinel(ctx.baseDir))) {
+export function defineLegacyMigrationTables(ctx: Context, force = false) {
+    if (!force && existsSync(getLegacySchemaSentinel(ctx.baseDir))) {
         return
     }
 
@@ -255,9 +255,10 @@ export function defineLegacyMigrationTables(ctx: Context) {
     )
 }
 
-function isMissingTableError(error: unknown) {
+export function isMissingTableError(error: unknown) {
     const message = String(error).toLowerCase()
     return (
+        message.includes('cannot resolve table') ||
         message.includes('no such table') ||
         message.includes('unknown table') ||
         message.includes('not found') ||

packages/core/src/migration/room_to_conversation.ts

@@ -1,3 +1,4 @@
+import { existsSync } from 'fs'
 import { createHash, randomUUID } from 'crypto'
 import type { Context } from 'koishi'
 import type { Config } from '../config'
@@ -15,13 +16,19 @@
     LegacyRoomRecord,
     LegacyUserRecord
 } from '../services/types'
-import { defineLegacyMigrationTables } from './legacy_tables'
+import {
+    defineLegacyMigrationTables,
+    isMissingTableError,
+    LEGACY_MIGRATION_TABLES
+} from './legacy_tables'
 import type { BindingProgress, MessageProgress, RoomProgress } from './types'
 import {
     aclKey,
     createLegacyBindingKey,
     createLegacyTableRetention,
+    createPassedValidationResult,
     filterValidRooms,
+    getLegacySchemaSentinel,
     inferLegacyGroupRouteModes,
     isComplexRoom,
     LEGACY_RETENTION_META_KEY,
@@ -43,7 +50,13 @@
     ctx: Context,
     config: Config
 ) {
-    defineLegacyMigrationTables(ctx)
+    const hasSentinel = existsSync(getLegacySchemaSentinel(ctx.baseDir))
+
+    if (hasSentinel && !(await hasLegacyMigrationData(ctx))) {
+        return ensureMigrationValidated(ctx, config)
+    }
+
+    defineLegacyMigrationTables(ctx, hasSentinel)
 
     const result = await readMetaValue<
         Awaited<ReturnType<typeof validateRoomMigration>>
@@ -56,6 +69,7 @@
         (await readMetaValue<boolean>(ctx, 'message_migration_done')) ?? false
 
     if (
+        !hasSentinel &&
         schemaVersion >= BUILTIN_SCHEMA_VERSION &&
         (result?.passed === true || (roomDone && messageDone))
     ) {
@@ -88,6 +102,9 @@
         throw new Error('ChatLuna migration validation failed.')
     }
 
+    // Mark completion before purge so a restart after writing the sentinel
+    // can resume from the finished state instead of re-reading legacy tables.
+    await writeMigrationDone(ctx)
     await purgeLegacyTables(ctx)
     await writeMigrationFinished(ctx)
 
@@ -99,67 +116,174 @@
 // runRoomToConversationMigration when flags indicate migration is incomplete,
 // while runRoomToConversationMigration only calls ensureMigrationValidated when
 // flags indicate it IS complete — so the two paths are mutually exclusive.
 export async function ensureMigrationValidated(ctx: Context, config: Config) {
+    const hasSentinel = existsSync(getLegacySchemaSentinel(ctx.baseDir))
+    const hasLegacyData = hasSentinel
+        ? await hasLegacyMigrationData(ctx)
+        : false
+
+    if (hasSentinel && hasLegacyData) {
+        ctx.logger.warn(
+            'Legacy sentinel exists but legacy ChatHub data is still present; continuing migration from legacy tables.'
+        )
+        defineLegacyMigrationTables(ctx, true)
+    }
+
     const result = await readMetaValue<
         Awaited<ReturnType<typeof validateRoomMigration>>
     >(ctx, 'validation_result')
     const retention = await readMetaValue<{
         state?: string
     }>(ctx, LEGACY_RETENTION_META_KEY)
 
+    if (hasSentinel) {
+        if (hasLegacyData) {
+            return runRoomToConversationMigration(ctx, config)
+        }
+
+        if (result?.passed === true) {
+            await writeMetaValue(ctx, 'schema_version', BUILTIN_SCHEMA_VERSION)
+            await writeMigrationDone(ctx)
+            await writeMigrationFinished(ctx)
+            return result
+        }
+
+        const conversations = (await ctx.database.get(
+            'chatluna_conversation',
+            {},
+            {
+                limit: 1
+            }
+        )) as ConversationRecord[]
+        const messages = (await ctx.database.get(
+            'chatluna_message',
+            {},
+            {
+                limit: 1
+            }
+        )) as MessageRecord[]
+        const bindings = (await ctx.database.get(
+            'chatluna_binding',
+            {},
+            {
+                limit: 1
+            }
+        )) as BindingRecord[]
+        const acl = (await ctx.database.get(
+            'chatluna_acl',
+            {},
+            {
+                limit: 1
+            }
+        )) as ACLRecord[]
+        const hasData =
+            conversations.length > 0 ||
+            messages.length > 0 ||
+            bindings.length > 0 ||
+            acl.length > 0
+
+        ctx.logger.warn(
+            hasData
+                ? 'Legacy sentinel exists and ChatLuna data is present; adopting current ChatLuna state and marking migration finished.'
+                : 'Legacy sentinel exists and ChatLuna data is empty; treating startup as fresh install.'
+        )
+
+        const validated = createPassedValidationResult()
+        await writeMetaValue(ctx, 'schema_version', BUILTIN_SCHEMA_VERSION)
+        await writeMetaValue(ctx, 'validation_result', validated)
+        await writeMigrationDone(ctx)
+        await writeMigrationFinished(ctx)
+        return validated
+    }
+
     if (result?.passed === true) {
+        await writeMetaValue(ctx, 'schema_version', BUILTIN_SCHEMA_VERSION)
+        await writeMigrationDone(ctx)
+
         if (retention?.state !== 'purged') {
             await purgeLegacyTables(ctx)
         }
 
         await writeMigrationFinished(ctx)
         return result
     }
 
     const schemaVersion =
         (await readMetaValue<number>(ctx, 'schema_version')) ?? 0
     const roomDone =
         (await readMetaValue<boolean>(ctx, 'room_migration_done')) ?? false
     const messageDone =
         (await readMetaValue<boolean>(ctx, 'message_migration_done')) ?? false
 
     if (
         schemaVersion < BUILTIN_SCHEMA_VERSION ||
         roomDone !== true ||
         messageDone !== true
     ) {
         // Migration is genuinely incomplete; restart it.
         // runRoomToConversationMigration will NOT call back into ensureMigrationValidated
         // because it only does so when all done-flags are true, which they are not here.
         return runRoomToConversationMigration(ctx, config)
     }
 
     if (retention?.state !== 'purged') {
         defineLegacyMigrationTables(ctx)
     }
 
     const validated = await validateRoomMigration(ctx, config)
     await writeMetaValue(ctx, 'validation_result', validated)
 
     if (!validated.passed) {
         throw new Error('ChatLuna migration validation failed.')
     }
 
+    await writeMigrationDone(ctx)
     await purgeLegacyTables(ctx)
     await writeMigrationFinished(ctx)
 
     return validated
 }
 
-async function writeMigrationFinished(ctx: Context) {
-    await writeMetaValue(ctx, 'migration_finished_at', new Date().toISOString())
+async function writeMigrationDone(ctx: Context) {
     await writeMetaValue(ctx, 'room_migration_done', true)
     await writeMetaValue(ctx, 'message_migration_done', true)
+}
+
+async function writeMigrationFinished(ctx: Context) {
     await writeMetaValue(
         ctx,
         LEGACY_RETENTION_META_KEY,
         createLegacyTableRetention('purged')
     )
+    await writeMetaValue(ctx, 'migration_finished_at', new Date().toISOString())
+}
+
+async function hasLegacyMigrationData(ctx: Context) {
+    defineLegacyMigrationTables(ctx, true)
+
+    for (const table of LEGACY_MIGRATION_TABLES) {
+        try {
+            if (
+                (
+                    await ctx.database.get(
+                        table as never,
+                        {},
+                        {
+                            limit: 1
+                        }
+                    )
+                ).length > 0
+            ) {
+                return true
+            }
+        } catch (error) {
+            if (!isMissingTableError(error)) {
+                throw error
+            }
+        }
+    }
+
+    return false
 }
 
 // (#6) removed redundant inner `done` check — the caller already guards on room_migration_done

packages/core/src/migration/validators.ts

@@ -17,9 +17,9 @@ import type {
 import type { MigrationValidationResult } from './types'
 export type { MigrationValidationResult } from './types'
 export {
+    getLegacySchemaSentinel,
     dropTableIfExists,
     getLegacySchemaSentinelDir,
-    getLegacySchemaSentinel,
     LEGACY_MIGRATION_TABLES,
     LEGACY_RETENTION_META_KEY,
     LEGACY_RUNTIME_TABLES,
@@ -30,6 +30,42 @@ export {
 
 const VALIDATION_BATCH_SIZE = 500
 
+export function createPassedValidationResult(): MigrationValidationResult {
+    return {
+        passed: true,
+        checkedAt: new Date().toISOString(),
+        conversation: {
+            legacy: 0,
+            migrated: 0,
+            matched: true
+        },
+        message: {
+            legacy: 0,
+            migrated: 0,
+            matched: true
+        },
+        latestMessageId: {
+            missingConversationIds: [],
+            matched: true
+        },
+        bindingKey: {
+            inconsistentConversationIds: [],
+            matched: true
+        },
+        binding: {
+            missingBindingKeys: [],
+            missingConversationIds: [],
+            matched: true
+        },
+        acl: {
+            expected: 0,
+            migrated: 0,
+            missing: [],
+            matched: true
+        }
+    }
+}
+
 export async function validateRoomMigration(ctx: Context, _config: Config) {
     ctx.logger.info('Validating built-in ChatLuna migration.')
 

packages/core/src/services/conversation.ts

@@ -336,8 +336,6 @@ export class ConversationService {
             }
         }
 
-        await assertManageAllowed(session, resolved.constraint)
-
         if (!resolved.constraint.allowNew) {
             throw new Error('Conversation creation is disabled by constraint.')
         }