@lark-codem/codem-cli 0.1.235-dev.100102679703.0.g4115fa5 → 0.1.235

package/profile/profile-migration.js

@@ -0,0 +1,1022 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, unlink } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { z } from 'zod';
+import { writeFileAtomically, writeJsonFileAtomically } from './profile-io.js';
+import { probeProcessLiveness } from './profile-io.js';
+import { resolveProfileUser as resolveCodeMAuthenticationUser } from './profile-snapshot.js';
+import { samePathForPlatform } from './profile-io.js';
+import { withCodeMConfigLock } from './profile-io.js';
+import { CODEM_PROFILE_SESSION_TREES, CodeMProfileWriterBusyError, CodeMProfileWriterInspectionError, requireIdleProfileSessions } from './profile-writers.js';
+const LEGACY_HISTORY_OWNER_FILE = 'app-session-owner.json';
+const DEFERRED_IDENTITY_SELECTION_FILE = 'app-profile-recovery-pending.json';
+const IDENTITY_FILES = [
+    'config.json.journal',
+    '.credentials.json',
+    'device-rebind.journal',
+    LEGACY_HISTORY_OWNER_FILE,
+    DEFERRED_IDENTITY_SELECTION_FILE,
+    'credential-storage.json',
+    'config.json'
+];
+const HashSchema = z.string().regex(/^[a-f0-9]{64}$/u).nullable();
+const TransactionSchema = z.strictObject({
+    version: z.literal(1),
+    phase: z.enum([
+        'prepared',
+        'identity-applied'
+    ]),
+    id: z.string().uuid(),
+    targetHome: z.string(),
+    homes: z.array(z.string()),
+    files: z.array(z.strictObject({
+        path: z.string(),
+        before: HashSchema,
+        after: HashSchema
+    })),
+    archivedSessions: z.array(z.string())
+});
+export class CodeMProfileMigrationError extends Error {
+}
+export class CodeMProfileMigrationBlockedError extends CodeMProfileMigrationError {
+    code = 'CODEM_PROFILE_MIGRATION_BLOCKED';
+    reason;
+    blockers;
+    constructor(detail, reason, blockers, options){
+        super(detail, options);
+        this.name = 'CodeMProfileMigrationBlockedError';
+        this.reason = reason;
+        this.blockers = blockers;
+    }
+}
+export async function migrateCodeMProfile(options) {
+    const target = await canonicalCodeMProfileHome(options.targetHome);
+    const homes = [];
+    for (const home of (await Promise.all([
+        target,
+        ...options.legacyHomes
+    ].map(canonicalCodeMProfileHome)))){
+        if (!homes.includes(home)) homes.push(home);
+    }
+    const { backupHome, pending } = await findPendingMigration(options.backupHome, target);
+    const profiles = [];
+    for (const home of homes){
+        let bundle = new Map();
+        let unreadable = false;
+        let readIssue = null;
+        try {
+            bundle = await readBundle(home);
+        } catch (error) {
+            unreadable = true;
+            readIssue = message(error);
+        }
+        let identity = null;
+        let issue = readIssue;
+        let foreign = false;
+        try {
+            if (!unreadable) identity = inspectProfile(home, bundle, options.serverOrigin);
+        } catch (error) {
+            issue = message(error);
+            foreign = issue.includes('其他服务环境');
+        }
+        let hasHistory = false;
+        try {
+            hasHistory = (await Promise.all(CODEM_PROFILE_SESSION_TREES.map(async (name)=>{
+                const info = await optionalStat(join(home, name));
+                return Boolean(info && (!info.isDirectory() || (await readdir(join(home, name))).length));
+            }))).some(Boolean);
+        } catch (error) {
+            unreadable = true;
+            issue = message(error);
+        }
+        if (!issue && bundle.get('device-rebind.journal')) issue = '上次设备连接未完成，可以备份并恢复；结果不明确时需要重新登录。';
+        if (!issue && !identity && bundle.get('config.json.journal')) issue = '登录资料存在未完成的更新，需要恢复。';
+        if (!issue && bundle.get('.credentials.json')) {
+            try {
+                parseObject(bundle.get('.credentials.json'), home);
+            } catch (error) {
+                issue = message(error);
+            }
+        }
+        let blocker = null;
+        try {
+            await requireDaemonStopped(home);
+        } catch (error) {
+            blocker = profileMigrationBlocker(error, home, 'writer-inspection-failed');
+        }
+        try {
+            await requireIdleProfileSessions(home);
+        } catch (error) {
+            blocker ??= profileMigrationBlocker(error, home, 'writer-inspection-failed');
+        }
+        profiles.push({
+            home,
+            bundle,
+            identity,
+            issue,
+            foreign,
+            hasHistory,
+            blocker,
+            unreadable
+        });
+    }
+    const sources = profiles.filter((profile)=>!profile.foreign || profile.home === target);
+    const canonical = sources.find((profile)=>profile.home === target);
+    const legacy = sources.filter((profile)=>profile.home !== target && hasData(profile));
+    const hasIdentity = (profile)=>Boolean(profile.identity && !profile.unreadable && !profile.foreign);
+    const hasDeferredIdentitySelection = (profile)=>Boolean(profile.bundle.get(DEFERRED_IDENTITY_SELECTION_FILE));
+    if (pending) {
+        const transaction = await parseTransaction(pending, homes, target);
+        let credentialStorage;
+        try {
+            credentialStorage = sources.some((profile)=>hasCredentialStorage(profile.bundle)) || await hasTransactionCredentials(transaction, backupHome);
+        } catch (error) {
+            if (options.mode !== 'automatic' || !hasIdentity(canonical) || canonical.issue) throw error;
+            reportDeferredLegacyConsolidation(error);
+            return {
+                kind: 'ready',
+                backupHome: join(backupHome, transaction.id),
+                legacyCleanupPending: true
+            };
+        }
+        if (credentialStorage) {
+            if (options.mode === 'automatic' && hasIdentity(canonical)) {
+                return {
+                    kind: 'ready',
+                    backupHome: join(backupHome, transaction.id),
+                    legacyCleanupPending: true
+                };
+            }
+            throw new CodeMProfileMigrationError('系统凭据资料需要由 CodeM CLI 迁移，当前已保留原资料和备份，请稍后重试。');
+        }
+        if (hasIdentity(canonical)) {
+            const transactionProfiles = profiles.filter((profile)=>transaction.homes.includes(profile.home));
+            if (transactionProfiles.some((profile)=>profile.blocker !== null)) {
+                return {
+                    kind: 'ready',
+                    backupHome: join(backupHome, transaction.id),
+                    legacyCleanupPending: true
+                };
+            }
+            let completed = false;
+            try {
+                await withProfileLocks(transaction.homes, async ()=>{
+                    if (!sameBundle(canonical.bundle, await readBundle(target))) {
+                        throw new CodeMProfileMigrationError('登录资料已更新，请重新打开 CodeM。');
+                    }
+                    await requireTransactionSessionsIdle(transaction);
+                    await options.migrateSessions(transactionSessionRoots(transaction));
+                    await rm(join(backupHome, 'pending.json'));
+                });
+                completed = true;
+            } catch (error) {
+                reportDeferredLegacyConsolidation(error);
+            }
+            return {
+                kind: 'ready',
+                backupHome: join(backupHome, transaction.id),
+                legacyCleanupPending: !completed || legacy.length > 0
+            };
+        }
+        if (await retireSupersededPreparedTransaction(transaction, backupHome, pending, [
+            ...new Set([
+                ...transaction.homes,
+                ...sources.map((profile)=>profile.home)
+            ])
+        ], options.serverOrigin)) {
+            return migrateCodeMProfile(options);
+        }
+        await withProfileLocks(transaction.homes, ()=>completeTransaction(transaction, backupHome, options.migrateSessions));
+        return {
+            kind: 'ready',
+            backupHome: join(backupHome, transaction.id),
+            legacyCleanupPending: legacy.some((profile)=>!transaction.homes.includes(profile.home))
+        };
+    }
+    let selected;
+    let fresh = false;
+    let affectedProfiles = [];
+    let preserveSelectedIdentity = false;
+    let preserveLegacyIdentities = false;
+    const maintenance = options.mode === 'maintenance';
+    const candidates = legacy.filter(hasIdentity);
+    const primaryLegacyHome = options.legacyHomes[0] ? await canonicalCodeMProfileHome(options.legacyHomes[0]) : null;
+    const primary = candidates.find((profile)=>profile.home === primaryLegacyHome);
+    const first = candidates[0];
+    const equivalent = first !== undefined && candidates.every((profile)=>profile.identity?.deviceId === first.identity?.deviceId && profile.identity?.accountKey === first.identity?.accountKey);
+    if (maintenance) {
+        const recommended = hasIdentity(canonical) ? canonical : primary ?? first ?? sources.find((profile)=>hasData(profile) && !profile.foreign) ?? canonical;
+        const identities = [
+            canonical,
+            ...candidates
+        ].flatMap((profile)=>profile.identity ? [
+                profile.identity
+            ] : []);
+        const sameAccount = Boolean(identities[0]?.accountKey && identities.every((identity)=>identity.accountKey === identities[0]?.accountKey));
+        const snapshot = {
+            stage: 'choice',
+            situation: sources.some((profile)=>hasData(profile) && (profile.issue || profile.unreadable || profile.blocker !== null)) || identities.length < 2 ? 'recovery' : sameAccount ? 'devices' : 'accounts',
+            targetHome: target,
+            environment: options.serverOrigin,
+            backupHome,
+            profiles: sources.filter(hasData).map(profileSetupProfile),
+            recommendedHome: recommended.home,
+            busy: sources.some((profile)=>hasData(profile) && profile.blocker !== null),
+            blockers: [],
+            notice: null,
+            diagnosticId: null
+        };
+        const choice = await options.choose(snapshot);
+        if (choice.kind === 'defer') return {
+            kind: 'defer'
+        };
+        if (choice.kind === 'new') {
+            selected = canonical;
+            fresh = true;
+        } else if (choice.kind === 'migrate') {
+            const selectedHome = await canonicalCodeMProfileHome(choice.home);
+            const chosen = sources.find((profile)=>profile.home === selectedHome);
+            if (!chosen || chosen.foreign) {
+                throw new CodeMProfileMigrationError('所选资料不属于当前环境，请重新选择。');
+            }
+            selected = chosen;
+        } else {
+            throw new CodeMProfileMigrationError('请选择需要使用的资料。');
+        }
+    } else if (hasIdentity(canonical) || hasDeferredIdentitySelection(canonical)) {
+        selected = canonical;
+        preserveSelectedIdentity = true;
+        preserveLegacyIdentities = !hasIdentity(canonical);
+        if (canonical.blocker !== null) {
+            return {
+                kind: 'ready',
+                backupHome: null,
+                legacyCleanupPending: legacy.length > 0 || Boolean(canonical.bundle.get(LEGACY_HISTORY_OWNER_FILE))
+            };
+        }
+        affectedProfiles = [
+            canonical,
+            ...legacy.filter((profile)=>!profile.unreadable && profile.blocker === null)
+        ];
+        const hasLegacyWork = preserveLegacyIdentities ? affectedProfiles.some((profile)=>profile.home !== target && profile.hasHistory) : affectedProfiles.length > 1;
+        const hasLegacyOwnerMarker = Boolean(canonical.bundle.get(LEGACY_HISTORY_OWNER_FILE));
+        const canonicalSessionsAreLinked = Boolean((await optionalStat(join(target, 'sessions')))?.isSymbolicLink());
+        const hasObsoleteDeferredSelection = hasIdentity(canonical) && hasDeferredIdentitySelection(canonical);
+        if (!hasLegacyWork && !hasLegacyOwnerMarker && !canonicalSessionsAreLinked && !hasObsoleteDeferredSelection) {
+            return {
+                kind: 'ready',
+                backupHome: null,
+                legacyCleanupPending: legacy.length > 0
+            };
+        }
+    } else {
+        const ambiguous = !primary && candidates.length > 1 && !equivalent;
+        selected = ambiguous ? canonical : primary ?? first ?? canonical;
+        fresh = !selected.identity;
+        preserveSelectedIdentity = Boolean(selected.identity);
+        preserveLegacyIdentities = ambiguous;
+    }
+    if (!(!maintenance && selected === canonical && hasIdentity(canonical))) {
+        if (selected.unreadable) {
+            throw new CodeMProfileMigrationError(`无法备份该资料目录，请检查权限后重试：${selected.home}`);
+        }
+        const selectedSourceIsBusy = selected.home !== target && selected.blocker !== null;
+        if (maintenance && selected.blocker !== null) {
+            throw selected.blocker;
+        }
+        affectedProfiles = [
+            canonical,
+            ...legacy.filter((profile)=>!profile.unreadable && profile.blocker === null && !selectedSourceIsBusy)
+        ];
+        if (!selectedSourceIsBusy && !affectedProfiles.includes(selected)) {
+            affectedProfiles.push(selected);
+        }
+    }
+    const deferredLegacyProfiles = legacy.filter((profile)=>!affectedProfiles.includes(profile));
+    for (const profile of affectedProfiles){
+        if (profile.blocker !== null) throw profile.blocker;
+    }
+    try {
+        if (hasCredentialStorage(selected.bundle) || affectedProfiles.some((profile)=>hasCredentialStorage(profile.bundle))) {
+            if (!maintenance && hasIdentity(canonical)) {
+                return {
+                    kind: 'ready',
+                    backupHome: null,
+                    legacyCleanupPending: legacy.length > 0
+                };
+            }
+            return {
+                kind: 'defer'
+            };
+        }
+    } catch (error) {
+        if (options.mode !== 'automatic' || !hasIdentity(canonical) || canonical.issue) throw error;
+        reportDeferredLegacyConsolidation(error);
+        return {
+            kind: 'ready',
+            backupHome: null,
+            legacyCleanupPending: true
+        };
+    }
+    const affected = affectedProfiles.map((profile)=>profile.home);
+    const lockedHomes = [
+        ...new Set([
+            ...affected,
+            selected.home
+        ])
+    ];
+    const pendingPath = join(backupHome, 'pending.json');
+    try {
+        return await withProfileLocks(lockedHomes, async ()=>{
+            for (const profile of affectedProfiles){
+                if (profile.hasHistory) await requireIdleProfile(profile.home);
+                if (!sameBundle(profile.bundle, await readBundle(profile.home))) {
+                    throw new CodeMProfileMigrationError(`确认期间登录资料发生变化，请重试：${profile.home}`);
+                }
+            }
+            if (!affectedProfiles.includes(selected) && !sameBundle(selected.bundle, await readBundle(selected.home))) {
+                throw new CodeMProfileMigrationError(`自动迁移期间登录资料发生变化，请重新打开 CodeM：${selected.home}`);
+            }
+            const id = randomUUID();
+            const directory = join(backupHome, id);
+            await mkdir(directory, {
+                recursive: true,
+                mode: 0o700
+            });
+            const files = [];
+            const next = prepareSelectedBundle(selected, options.serverOrigin, fresh, target, preserveSelectedIdentity);
+            next.set(DEFERRED_IDENTITY_SELECTION_FILE, preserveLegacyIdentities && !selected.identity ? Buffer.from('{"version":1}\n') : null);
+            if (pending) await writeFileAtomically(join(directory, 'previous-pending.json'), pending, 'previous migration recovery');
+            for (const home of [
+                target,
+                ...affected.filter((candidate)=>candidate !== target)
+            ]){
+                const bundle = affectedProfiles.find((profile)=>profile.home === home).bundle;
+                for (const name of IDENTITY_FILES){
+                    const before = bundle.get(name) ?? null;
+                    const after = home === target ? next.get(name) ?? null : preserveLegacyIdentities ? before : null;
+                    if (digest(before) === digest(after)) continue;
+                    const index = files.length;
+                    if (before) await writeFileAtomically(join(directory, `${index}.before`), before, 'profile backup');
+                    if (after) await writeFileAtomically(join(directory, `${index}.after`), after, 'profile migration target');
+                    files.push({
+                        path: join(home, name),
+                        before: digest(before),
+                        after: digest(after)
+                    });
+                }
+            }
+            await requireIdentityWritersStopped(files);
+            const transaction = {
+                version: 1,
+                phase: 'prepared',
+                id,
+                targetHome: target,
+                homes: affected,
+                files,
+                archivedSessions: []
+            };
+            await writeJsonFileAtomically(join(directory, 'transaction.json'), transaction, 'profile migration receipt');
+            await writeJsonFileAtomically(pendingPath, transaction, 'pending profile migration');
+            await completeTransaction(transaction, backupHome, options.migrateSessions);
+            return {
+                kind: 'ready',
+                backupHome: directory,
+                legacyCleanupPending: preserveLegacyIdentities || deferredLegacyProfiles.length > 0
+            };
+        });
+    } catch (error) {
+        if (!hasIdentity(canonical) || !await hasCanonicalIdentity(target, options.serverOrigin)) throw error;
+        reportDeferredLegacyConsolidation(error);
+        return {
+            kind: 'ready',
+            backupHome: null,
+            legacyCleanupPending: legacy.length > 0
+        };
+    }
+}
+function hasCredentialStorage(bundle) {
+    if (bundle.get('credential-storage.json')) return true;
+    for (const name of [
+        'config.json',
+        '.credentials.json'
+    ]){
+        const bytes = bundle.get(name);
+        if (!bytes) continue;
+        // Unreadable JSON cannot prove the absence of a secure storage reference.
+        if (parseObject(bytes, name).credentialStorageRef != null) return true;
+    }
+    return false;
+}
+async function hasTransactionCredentials(transaction, backupHome) {
+    for (const [index, file] of transaction.files.entries()){
+        const name = basename(file.path);
+        if (name === 'credential-storage.json') return true;
+        if (name !== 'config.json' && name !== '.credentials.json') continue;
+        for (const side of [
+            'before',
+            'after'
+        ]){
+            if (!file[side]) continue;
+            const bytes = await readOptional(join(backupHome, transaction.id, `${index}.${side}`));
+            if (hasCredentialStorage(new Map([
+                [
+                    name,
+                    bytes
+                ]
+            ]))) return true;
+        }
+    }
+    return false;
+}
+function hasData(profile) {
+    return profile.unreadable || profile.hasHistory || [
+        ...profile.bundle.values()
+    ].some(Boolean);
+}
+function profileSetupProfile(profile) {
+    return {
+        home: profile.home,
+        accountKey: profile.identity?.accountKey ?? null,
+        accountLabel: profile.identity?.accountLabel ?? '待恢复的资料',
+        deviceId: profile.identity?.deviceId ?? null,
+        status: profile.foreign ? 'other-environment' : profile.issue || profile.unreadable ? 'recovery' : profile.identity?.signedIn ? 'available' : 'signed-out',
+        issue: profile.issue
+    };
+}
+function prepareSelectedBundle(profile, origin, fresh, targetHome, preserveIdentity) {
+    const next = new Map(profile.bundle);
+    next.set(LEGACY_HISTORY_OWNER_FILE, null);
+    if (preserveIdentity) {
+        if (profile.home !== targetHome) removeDerivedCredentials(next, profile.home);
+        return next;
+    }
+    if (!fresh && profile.home === targetHome && !profile.issue) return next;
+    let config;
+    try {
+        config = parseObject(next.get('config.json') ?? Buffer.from('{}'), profile.home);
+    } catch  {
+        config = {};
+    }
+    const original = profile.identity;
+    const journal = next.get('device-rebind.journal');
+    let requireLogin = fresh || !profile.identity;
+    if (journal && !fresh) {
+        requireLogin = true;
+        let entry = null;
+        try {
+            entry = parseObject(journal, profile.home);
+        } catch  {}
+        const bound = object(entry?.boundDevice);
+        const boundId = string(bound?.deviceId);
+        const previous = string(entry?.previousDeviceId);
+        const daemonRecord = entry?.source === undefined || entry.source === 'daemon';
+        if (entry?.version === 1 && daemonRecord && original?.signedIn && boundId && string(bound?.deviceSecret) && previous === original.deviceId) {
+            config.device = {
+                ...object(config.device),
+                deviceId: boundId,
+                deviceSecret: bound?.deviceSecret,
+                ...typeof bound?.defaultWorkDirectory === 'string' ? {
+                    defaultWorkDirectory: bound.defaultWorkDirectory
+                } : {},
+                ...typeof bound?.cliVersion === 'string' ? {
+                    cliVersion: bound.cliVersion
+                } : {}
+            };
+            requireLogin = false;
+        } else if (entry?.version === 1 && original && previous && previous !== original.deviceId && boundId !== original.deviceId && daemonRecord) {
+            requireLogin = false;
+        } else if (entry?.version === 1 && boundId && string(bound?.deviceSecret)) {
+            config.device = {
+                deviceId: boundId
+            };
+        }
+    }
+    if (requireLogin) {
+        let verifiedEnvironment = false;
+        try {
+            const url = new URL(String(config.serverUrl));
+            verifiedEnvironment = url.origin === origin && !url.username && !url.password && !url.search && !url.hash;
+        } catch  {}
+        const anchor = verifiedEnvironment ? string(object(config.device)?.deviceId ?? object(config.device)?.device_id) : null;
+        config = {
+            serverUrl: origin,
+            device: anchor && anchor.length <= 128 ? {
+                deviceId: anchor
+            } : null,
+            auth: {
+                oauth: null
+            },
+            user: null
+        };
+        next.set('config.json.journal', null);
+    }
+    next.set('device-rebind.journal', null);
+    next.set('config.json', Buffer.from(`${JSON.stringify(config)}\n`));
+    removeDerivedCredentials(next, profile.home);
+    return next;
+}
+function removeDerivedCredentials(bundle, home) {
+    let credentials = null;
+    try {
+        if (bundle.get('.credentials.json')) {
+            credentials = parseObject(bundle.get('.credentials.json'), home);
+        }
+    } catch  {}
+    if (credentials) delete credentials.codemAiOauth;
+    bundle.set('.credentials.json', credentials ? Buffer.from(`${JSON.stringify(credentials)}\n`) : null);
+}
+function message(error) {
+    return error instanceof CodeMProfileMigrationError ? error.message : '无法读取资料，请检查目录权限后重试。';
+}
+function reportDeferredLegacyConsolidation(error) {
+    console.warn('Deferred legacy CodeM profile consolidation; the canonical profile remains active', error instanceof Error ? error.message : 'unknown error');
+}
+async function retireSupersededPreparedTransaction(transaction, backupHome, pending, recoveryHomes, serverOrigin) {
+    if (transaction.phase !== 'prepared') return false;
+    return withProfileLocks(recoveryHomes, async ()=>{
+        const bundles = await readProfileBundles(recoveryHomes);
+        const decision = preparedTransactionDecision(transaction, bundles, serverOrigin);
+        if (decision === 'conflict') {
+            throw new CodeMProfileMigrationError('未完成迁移中的登录资料再次发生冲突，已保留备份，请联系支持。');
+        }
+        if (decision === 'resume' || await hasTransactionSessionArchive(transaction)) return false;
+        await requireProfileHomesIdle(recoveryHomes);
+        const confirmed = await readProfileBundles(recoveryHomes);
+        if (preparedTransactionDecision(transaction, confirmed, serverOrigin) !== 'restart' || await hasTransactionSessionArchive(transaction)) {
+            throw new CodeMProfileMigrationError('登录资料正在更新，请重新打开 CodeM。');
+        }
+        const directory = join(backupHome, transaction.id);
+        await writeFileAtomically(join(directory, 'superseded-pending.json'), pending, 'superseded profile migration');
+        await rm(join(backupHome, 'pending.json'));
+        console.warn('Restarting prepared CodeM profile migration from a newer legacy identity');
+        return true;
+    });
+}
+async function readProfileBundles(homes) {
+    return new Map(await Promise.all(homes.map(async (home)=>[
+            home,
+            await readBundle(home)
+        ])));
+}
+function preparedTransactionDecision(transaction, bundles, serverOrigin) {
+    const targetBundle = bundles.get(transaction.targetHome);
+    if (!targetBundle) return 'conflict';
+    try {
+        if (inspectProfile(transaction.targetHome, targetBundle, serverOrigin)) {
+            return 'resume';
+        }
+    } catch  {
+        return 'conflict';
+    }
+    const recordedPaths = new Set(transaction.files.map((file)=>file.path));
+    let legacyChanged = false;
+    let transactionApplied = false;
+    for (const file of transaction.files){
+        const current = digest(bundles.get(dirname(file.path))?.get(basename(file.path)) ?? null);
+        if (dirname(file.path) === transaction.targetHome) {
+            if (current === file.after) transactionApplied = true;
+            else if (current !== file.before) return 'conflict';
+            continue;
+        }
+        if (current === file.after) transactionApplied = true;
+        else if (current !== file.before) legacyChanged = true;
+    }
+    for (const home of bundles.keys()){
+        if (home === transaction.targetHome) continue;
+        const bundle = bundles.get(home);
+        if (!bundle) return 'conflict';
+        if (IDENTITY_FILES.some((name)=>bundle.get(name) && !recordedPaths.has(join(home, name)))) {
+            legacyChanged = true;
+        }
+    }
+    if (!legacyChanged) return 'resume';
+    if (transactionApplied) return 'conflict';
+    const identities = [];
+    for (const home of bundles.keys()){
+        if (home === transaction.targetHome) continue;
+        const bundle = bundles.get(home);
+        if (!bundle) return 'conflict';
+        try {
+            const identity = inspectProfile(home, bundle, serverOrigin);
+            if (identity) identities.push(identity);
+        } catch  {
+            return 'conflict';
+        }
+    }
+    const first = identities[0];
+    return first && identities.every((identity)=>identity.deviceId === first.deviceId && identity.accountKey === first.accountKey) ? 'restart' : 'conflict';
+}
+async function requireProfileHomesIdle(homes) {
+    for (const home of homes){
+        await requireDaemonStopped(home);
+        const entries = await Promise.all(CODEM_PROFILE_SESSION_TREES.map((name)=>optionalStat(join(home, name))));
+        if (entries.some(Boolean)) await requireIdleProfile(home);
+    }
+}
+async function hasTransactionSessionArchive(transaction) {
+    for (const home of transaction.archivedSessions){
+        for (const name of CODEM_PROFILE_SESSION_TREES){
+            const root = join(home, '.app-profile-archive', transaction.id);
+            if (await optionalStat(join(root, name)) || await optionalStat(join(root, 'conflicts', name))) return true;
+        }
+    }
+    return false;
+}
+async function hasCanonicalIdentity(home, origin) {
+    try {
+        const bundle = await readBundle(home);
+        return Boolean(inspectProfile(home, bundle, origin));
+    } catch  {
+        return false;
+    }
+}
+async function completeTransaction(transaction, backupHome, migrateSessions) {
+    const pendingPath = join(backupHome, 'pending.json');
+    await requireTransactionReady(transaction);
+    if (transaction.phase === 'prepared') {
+        await applyTransaction(transaction, backupHome);
+        await writeJsonFileAtomically(pendingPath, {
+            ...transaction,
+            phase: 'identity-applied'
+        }, 'pending profile migration');
+    }
+    for (const file of transaction.files){
+        if (digest(await readOptional(file.path)) !== file.after) {
+            throw new CodeMProfileMigrationError(`迁移后资料被其他进程修改，已停止恢复；请保留备份并联系支持：${join(backupHome, transaction.id)}`);
+        }
+    }
+    await migrateSessions(transactionSessionRoots(transaction));
+    await rm(pendingPath);
+}
+async function applyTransaction(transaction, backupHome) {
+    const directory = join(backupHome, transaction.id);
+    await requireTransactionReady(transaction);
+    for (const [index, file] of transaction.files.entries()){
+        const current = digest(await readOptional(file.path));
+        if (current !== file.before && current !== file.after) {
+            throw new CodeMProfileMigrationError(`迁移后资料被其他进程修改，已停止恢复；请保留备份并联系支持：${directory}`);
+        }
+        for (const side of [
+            'before',
+            'after'
+        ]){
+            if (file[side] !== digest(await readOptional(join(directory, `${index}.${side}`)))) {
+                throw new CodeMProfileMigrationError(`资料迁移备份校验失败：${directory}`);
+            }
+        }
+    }
+    for (const home of transaction.homes){
+        if (home === transaction.targetHome) continue;
+        const sessions = join(home, 'sessions');
+        if (!(await optionalStat(sessions))?.isSymbolicLink()) continue;
+        const target = resolve(dirname(sessions), await readlink(sessions));
+        const actualTarget = await optionalRealpath(sessions);
+        if (!await isKnownTransactionSessionRoot(transaction, home, target, actualTarget)) {
+            throw new CodeMProfileMigrationError(`旧会话目录是未识别的链接，已停止迁移：${sessions}`);
+        }
+        await unlink(sessions);
+    }
+    const canonicalSessions = join(transaction.targetHome, 'sessions');
+    if (transaction.archivedSessions.includes(transaction.targetHome) && (await optionalStat(canonicalSessions))?.isSymbolicLink()) {
+        const source = await realpath(canonicalSessions);
+        if (!transaction.archivedSessions.some((home)=>join(home, 'sessions') === source)) {
+            throw new CodeMProfileMigrationError('待归档共享会话链接的目标发生变化，已停止迁移。');
+        }
+        await unlink(canonicalSessions);
+    }
+    for (const home of transaction.archivedSessions){
+        for (const name of CODEM_PROFILE_SESSION_TREES){
+            const source = join(home, name);
+            const archive = join(home, '.app-profile-archive', transaction.id, name);
+            const sourceStat = await optionalStat(source);
+            const archivedStat = await optionalStat(archive);
+            if (!sourceStat) continue;
+            if (sourceStat.isSymbolicLink()) {
+                if (await realpath(source) === await realpath(join(transaction.targetHome, 'sessions'))) continue;
+                throw new CodeMProfileMigrationError(`旧会话目录是未识别的链接，已停止迁移：${source}`);
+            }
+            if (!sourceStat.isDirectory() || archivedStat) {
+                throw new CodeMProfileMigrationError(`会话归档状态发生冲突，已停止迁移：${source}`);
+            }
+            await mkdir(join(home, '.app-profile-archive', transaction.id), {
+                recursive: true,
+                mode: 0o700
+            });
+            await rename(source, archive);
+        }
+    }
+    for (const [index, file] of transaction.files.entries()){
+        const current = digest(await readOptional(file.path));
+        if (current === file.after) continue;
+        if (current !== file.before) throw new CodeMProfileMigrationError(`迁移时资料发生变化：${file.path}`);
+        if (file.after === null) await rm(file.path);
+        else await writeFileAtomically(file.path, await readOptional(join(directory, `${index}.after`)), 'CodeM profile');
+    }
+    for (const file of transaction.files){
+        if (digest(await readOptional(file.path)) !== file.after) {
+            throw new CodeMProfileMigrationError(`迁移结果校验失败：${file.path}`);
+        }
+    }
+}
+async function isKnownTransactionSessionRoot(transaction, sourceHome, linkTarget, actualTarget) {
+    const canonicalSessions = await canonicalCodeMProfileHome(join(transaction.targetHome, 'sessions'));
+    if (samePathForPlatform(linkTarget, canonicalSessions, process.platform)) {
+        return actualTarget === null || samePathForPlatform(actualTarget, canonicalSessions, process.platform);
+    }
+    if (actualTarget === null) return false;
+    if (!(await optionalStat(linkTarget))?.isDirectory()) return false;
+    for (const home of transaction.homes){
+        if (home === sourceHome || home === transaction.targetHome) continue;
+        const candidate = join(home, 'sessions');
+        if (!samePathForPlatform(linkTarget, candidate, process.platform)) continue;
+        if (!(await optionalStat(candidate))?.isDirectory()) continue;
+        if (samePathForPlatform(actualTarget, await canonicalCodeMProfileHome(candidate), process.platform)) {
+            return true;
+        }
+    }
+    return false;
+}
+function transactionSessionRoots(transaction) {
+    const roots = transaction.homes.flatMap((home)=>CODEM_PROFILE_SESSION_TREES.map((name)=>join(home, name)));
+    for (const home of transaction.archivedSessions){
+        for (const name of CODEM_PROFILE_SESSION_TREES){
+            roots.push(join(home, '.app-profile-archive', transaction.id, name));
+            roots.push(join(home, '.app-profile-archive', transaction.id, 'conflicts', name));
+        }
+    }
+    return [
+        ...new Set(roots)
+    ];
+}
+async function requireTransactionReady(transaction) {
+    const pendingFiles = [];
+    for (const file of transaction.files){
+        if (digest(await readOptional(file.path)) !== file.after) pendingFiles.push(file);
+    }
+    await requireIdentityWritersStopped(pendingFiles);
+    await requireTransactionSessionsIdle(transaction);
+}
+async function requireTransactionSessionsIdle(transaction) {
+    for (const home of transaction.homes){
+        const entries = await Promise.all(CODEM_PROFILE_SESSION_TREES.map((name)=>optionalStat(join(home, name))));
+        if (entries.some(Boolean)) await requireIdleProfile(home);
+    }
+}
+async function requireIdentityWritersStopped(files) {
+    const homes = new Set(files.filter((file)=>basename(file.path) !== LEGACY_HISTORY_OWNER_FILE).map((file)=>dirname(file.path)));
+    for (const home of homes){
+        await requireDaemonStopped(home);
+        await requireIdleProfile(home);
+    }
+}
+async function findPendingMigration(root, target) {
+    const canonicalBackup = join(root, hash(Buffer.from(target)));
+    const canonicalPending = await readPending(canonicalBackup);
+    const candidates = canonicalPending ? [
+        {
+            backupHome: canonicalBackup,
+            pending: canonicalPending
+        }
+    ] : [];
+    const entries = await readdir(root, {
+        withFileTypes: true
+    }).catch((error)=>{
+        if (isMissing(error) || error instanceof Error && 'code' in error && error.code === 'ENOTDIR') return [];
+        throw error;
+    });
+    for (const entry of entries){
+        const backupHome = join(root, entry.name);
+        if (!entry.isDirectory() || !/^[a-f0-9]{64}$/u.test(entry.name) || backupHome === canonicalBackup) continue;
+        try {
+            const pending = await readPending(backupHome);
+            if (!pending) continue;
+            const parsed = TransactionSchema.safeParse(JSON.parse(pending.toString('utf8')));
+            if (!parsed.success || !isAbsolute(parsed.data.targetHome)) continue;
+            if (await canonicalCodeMProfileHome(parsed.data.targetHome) === target) candidates.push({
+                backupHome,
+                pending
+            });
+        } catch  {}
+    }
+    if (candidates.length > 1) throw new CodeMProfileMigrationError('该资料存在多份未完成的迁移记录。备份已保留，请选择其他资料目录或暂不处理，并联系支持恢复。');
+    return candidates[0] ?? {
+        backupHome: canonicalBackup,
+        pending: null
+    };
+}
+async function readPending(backupHome) {
+    const path = join(backupHome, 'pending.json');
+    const info = await lstat(path).catch((error)=>{
+        if (isMissing(error) || error instanceof Error && 'code' in error && error.code === 'ENOTDIR') return null;
+        throw error;
+    });
+    return info ? readOptional(path) : null;
+}
+async function parseTransaction(bytes, homes, target) {
+    const parsed = TransactionSchema.safeParse(parseObject(bytes, '迁移记录'));
+    if (!parsed.success) throw new CodeMProfileMigrationError('资料迁移记录损坏，请保留现场并联系支持。');
+    const transaction = {
+        ...parsed.data,
+        targetHome: await canonicalCodeMProfileHome(parsed.data.targetHome),
+        homes: await Promise.all(parsed.data.homes.map(canonicalCodeMProfileHome)),
+        archivedSessions: await Promise.all(parsed.data.archivedSessions.map(canonicalCodeMProfileHome)),
+        files: await Promise.all(parsed.data.files.map(async (file)=>({
+                ...file,
+                path: join(await canonicalCodeMProfileHome(dirname(file.path)), basename(file.path))
+            })))
+    };
+    const permitted = new Set(homes.flatMap((home)=>IDENTITY_FILES.map((name)=>join(home, name))));
+    if (transaction.targetHome !== target || !transaction.homes.includes(target) || new Set(transaction.homes).size !== transaction.homes.length || new Set(transaction.files.map((file)=>file.path)).size !== transaction.files.length || transaction.homes.some((home)=>!homes.includes(home)) || transaction.archivedSessions.some((home)=>!homes.includes(home)) || transaction.files.some((file)=>!permitted.has(file.path))) {
+        throw new CodeMProfileMigrationError('资料迁移目录发生变化，请使用原目录完成恢复。');
+    }
+    return transaction;
+}
+function inspectProfile(home, bundle, serverOrigin) {
+    const bytes = bundle.get('config.json');
+    if (!bytes) {
+        return null;
+    }
+    const config = parseObject(bytes, home);
+    const device = object(config.device);
+    const oauth = object(object(config.auth)?.oauth);
+    const last = object(config.lastLoginUser ?? config.last_login_user);
+    const deviceId = string(device?.deviceId ?? device?.device_id);
+    const hasHistory = Boolean(oauth || last || device || config.user);
+    if (!deviceId) {
+        if (hasHistory) throw new CodeMProfileMigrationError(`已有登录资料缺少设备标识，已停止迁移以避免新建设备：${home}`);
+        return null;
+    }
+    if (deviceId.length > 128) throw new CodeMProfileMigrationError(`已有设备标识格式异常：${home}`);
+    let origin;
+    try {
+        const url = new URL(String(config.serverUrl));
+        if (url.username || url.password || url.search || url.hash) throw new Error('invalid server URL');
+        origin = url.origin;
+    } catch  {
+        throw new CodeMProfileMigrationError(`已有设备资料缺少有效服务地址：${home}`);
+    }
+    if (origin !== serverOrigin) throw new CodeMProfileMigrationError(`资料属于其他服务环境，不能混用：${home}`);
+    const user = resolveCodeMAuthenticationUser({
+        loggedIn: true,
+        authMethod: null,
+        routerCredential: null,
+        serverUrl: origin,
+        tenantId: null,
+        userId: null,
+        displayName: null
+    }, config);
+    const lastTenantId = string(last?.tenantId ?? last?.tenant_id);
+    const lastUserId = string(last?.userId ?? last?.user_id);
+    const tenantId = user.tenantId ?? lastTenantId;
+    const userId = user.userId ?? lastUserId;
+    if (lastUserId !== null && userId !== lastUserId || lastTenantId !== null && tenantId !== lastTenantId) {
+        throw new CodeMProfileMigrationError(`登录资料中的账号信息不一致：${home}`);
+    }
+    return {
+        home,
+        deviceId,
+        accountKey: tenantId && userId ? JSON.stringify([
+            origin,
+            tenantId,
+            userId
+        ]) : null,
+        accountLabel: user.displayName ?? string(last?.displayName ?? last?.display_name) ?? userId ?? '已退出的账号',
+        signedIn: Boolean(oauth && string(device?.deviceSecret ?? device?.device_secret))
+    };
+}
+async function readBundle(home) {
+    return new Map(await Promise.all(IDENTITY_FILES.map(async (name)=>[
+            name,
+            await readOptional(join(home, name))
+        ])));
+}
+async function requireDaemonStopped(home) {
+    const bytes = await readOptional(join(home, 'daemon.pid'));
+    if (bytes) {
+        const line = bytes.toString('utf8').split(/\r?\n/u)[0] ?? '';
+        const pid = /^\d+$/u.test(line) ? Number(line) : NaN;
+        if (!Number.isSafeInteger(pid) || pid <= 0) {
+            throw new CodeMProfileMigrationBlockedError(`无法确认该目录的后台服务状态，请检查资料后重试：${home}`, 'writer-inspection-failed', []);
+        }
+        const liveness = probeProcessLiveness(pid);
+        if (liveness.kind === 'missing') return;
+        throw new CodeMProfileMigrationBlockedError(`该目录的后台服务仍在运行或无法确认已退出。请先结束任务并暂停后台服务，然后在此页面重试：${home}`, liveness.kind === 'alive' ? 'daemon-active' : 'writer-inspection-failed', [
+            {
+                kind: 'cli-process',
+                processId: pid,
+                processName: 'codem-daemon'
+            }
+        ], liveness.kind === 'unavailable' ? {
+            cause: liveness.cause
+        } : undefined);
+    }
+}
+async function requireIdleProfile(home) {
+    try {
+        await requireIdleProfileSessions(home);
+    } catch (error) {
+        throw profileMigrationBlocker(error, home, 'writer-inspection-failed');
+    }
+}
+function profileMigrationBlocker(error, home, fallbackReason) {
+    if (error instanceof CodeMProfileMigrationBlockedError) return error;
+    if (error instanceof CodeMProfileWriterBusyError) {
+        return new CodeMProfileMigrationBlockedError(error.message, 'session-writer-active', error.blockers, {
+            cause: error
+        });
+    }
+    if (error instanceof CodeMProfileWriterInspectionError) {
+        return new CodeMProfileMigrationBlockedError(error.message, 'writer-inspection-failed', [], {
+            cause: error
+        });
+    }
+    return new CodeMProfileMigrationBlockedError(error instanceof Error ? error.message : `无法确认资料是否仍在使用：${home}`, fallbackReason, [], {
+        cause: error
+    });
+}
+async function withProfileLocks(homes, operation) {
+    const paths = [
+        ...homes
+    ].sort((left, right)=>left.localeCompare(right)).flatMap((home)=>[
+            join(home, '.credentials.json.shared'),
+            join(home, 'config.json'),
+            join(home, 'credential-storage.json')
+        ]);
+    const next = async (index)=>{
+        if (index < paths.length) return withCodeMConfigLock(paths[index], ()=>next(index + 1));
+        for (const home of homes){
+            if (hasCredentialStorage(await readBundle(home))) {
+                throw new CodeMProfileMigrationError('系统凭据资料需要由 CodeM CLI 迁移，当前已保留原资料和备份，请稍后重试。');
+            }
+        }
+        return operation();
+    };
+    return next(0);
+}
+export async function canonicalCodeMProfileHome(home) {
+    if (!isAbsolute(home)) throw new CodeMProfileMigrationError('CodeM 资料目录必须是绝对路径。');
+    let ancestor = resolve(home);
+    const tail = [];
+    for(;;){
+        try {
+            return join(await realpath(ancestor), ...tail);
+        } catch (error) {
+            const parent = dirname(ancestor);
+            if (!isMissing(error) || parent === ancestor) throw new CodeMProfileMigrationError(`无法访问资料目录：${home}`);
+            tail.unshift(basename(ancestor));
+            ancestor = parent;
+        }
+    }
+}
+async function readOptional(path) {
+    const info = await optionalStat(path);
+    if (!info) return null;
+    if (!info.isFile() || info.size > 16 * 1024 * 1024) throw new CodeMProfileMigrationError(`资料文件类型或大小异常：${path}`);
+    try {
+        return await readFile(path);
+    } catch  {
+        throw new CodeMProfileMigrationError(`无法读取资料文件：${path}`);
+    }
+}
+async function optionalStat(path) {
+    try {
+        return await lstat(path);
+    } catch (error) {
+        if (isMissing(error)) return null;
+        throw new CodeMProfileMigrationError(`无法访问资料路径：${path}`);
+    }
+}
+async function optionalRealpath(path) {
+    try {
+        return await realpath(path);
+    } catch (error) {
+        if (isMissing(error)) return null;
+        throw new CodeMProfileMigrationError(`无法访问资料路径：${path}`);
+    }
+}
+function parseObject(bytes, path) {
+    try {
+        const value = object(JSON.parse(bytes.toString('utf8')));
+        if (value) return value;
+    } catch  {}
+    throw new CodeMProfileMigrationError(`资料文件损坏：${path}`);
+}
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function string(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function isMissing(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+function hash(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function digest(bytes) {
+    return bytes === null ? null : hash(bytes);
+}
+function sameBundle(left, right) {
+    return IDENTITY_FILES.every((name)=>digest(left.get(name) ?? null) === digest(right.get(name) ?? null));
+}