evolcore 0.0.16 → 0.0.18

package/dist/utils/windows-autostart.js

@@ -1,9 +1,14 @@
 import fs from 'fs';
 import path from 'path';
 import { spawnSync } from 'child_process';
-import { getPackageRoot } from '../paths.js';
+import { getPackageRoot, resolvePaths } from '../paths.js';
+import { atomicReadJson, atomicWriteJson } from './atomic-write.js';
 import { decodeWindowsOutput } from './windows-output.js';
 export const WINDOWS_AUTOSTART_TASK_NAME = 'EvolCore';
+export const WINDOWS_AUTOSTART_RUN_VALUE_NAME = 'EvolCore';
+export const WINDOWS_AUTOSTART_STATE_VERSION = 1;
+const WINDOWS_RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run';
+const WRAPPER_MARKER = '# EvolCore managed login autostart wrapper v1';
 function isWindows() {
     return process.platform === 'win32';
 }
@@ -14,23 +19,39 @@ function runSchtasks(args) {
         timeout: 15_000,
     });
 }
+function runReg(args) {
+    return spawnSync('reg.exe', args, {
+        encoding: 'buffer',
+        windowsHide: true,
+        timeout: 15_000,
+    });
+}
+function resultOutput(result) {
+    return decodeWindowsOutput(result.stderr) || decodeWindowsOutput(result.stdout);
+}
 function commandError(result, fallback) {
-    const output = decodeWindowsOutput(result.stderr) || decodeWindowsOutput(result.stdout);
+    const output = resultOutput(result);
     const status = result.status == null ? '' : `（退出码 ${result.status}）`;
     const signal = result.signal ? `（信号 ${result.signal}）` : '';
     return `${result.error?.message || output || fallback}${status}${signal}`.trim();
 }
+function isAccessDenied(result) {
+    return result.status === 5
+        || /access is denied|access denied|拒绝访问|访问被拒绝/i.test(resultOutput(result));
+}
+function accessDeniedError(action, result) {
+    const retry = action === '启用' ? 'ec init --auto-start' : 'ec init --no-auto-start';
+    const exitDetail = result.status == null ? '' : `；schtasks 退出码 ${result.status}`;
+    return `Windows 任务计划程序拒绝访问（通常为系统错误码 5${exitDetail}）。`
+        + `当前 PowerShell/Windows Terminal 未获得管理员权限，或现有 \\${WINDOWS_AUTOSTART_TASK_NAME} 任务由提升权限创建。`
+        + `请右键终端选择“以管理员身份运行”，然后重新执行：${retry}。`
+        + '若自启动已由管理员配置且只需确认服务，请执行：ec status。';
+}
 function isTaskNotFoundMessage(message) {
     return /cannot find the file specified|系统找不到指定的文件|找不到指定的文件|指定的任务不存在|任务不存在/i.test(message);
 }
-function probeWindowsTask() {
-    const result = runSchtasks(['/Query', '/TN', WINDOWS_AUTOSTART_TASK_NAME]);
-    if (result.status === 0)
-        return { state: 'installed' };
-    const message = decodeWindowsOutput(result.stderr) || decodeWindowsOutput(result.stdout);
-    if (isTaskNotFoundMessage(message))
-        return { state: 'not-found' };
-    return { state: 'error', error: commandError(result, '查询 Windows 登录自启任务失败') };
+function isRegistryValueNotFoundMessage(message) {
+    return /unable to find|cannot find|系统找不到|找不到指定的注册表项|找不到指定的文件/i.test(message);
 }
 function powershellLiteral(value) {
     return `'${value.replace(/'/g, "''")}'`;
@@ -41,28 +62,40 @@ function windowsCommandLiteral(value) {
 function wrapperPath(runtimeRoot) {
     return path.join(runtimeRoot, 'data', 'evolcore-autostart.ps1');
 }
-export function windowsAutostartInstalled() {
-    if (!isWindows())
-        return false;
-    return probeWindowsTask().state === 'installed';
+function statePath(runtimeRoot) {
+    return path.join(runtimeRoot, 'data', 'autostart-state.json');
 }
-function createWrapper(runtimeRoot) {
-    const scriptPath = wrapperPath(runtimeRoot);
+function powershellPath() {
+    const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+    return path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+}
+function taskArguments(scriptPath) {
+    return `-NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File ${windowsCommandLiteral(scriptPath)}`;
+}
+function taskCommand(scriptPath) {
+    return `${windowsCommandLiteral(powershellPath())} ${taskArguments(scriptPath)}`;
+}
+function userRunCommand(scriptPath) {
+    return `${windowsCommandLiteral(powershellPath())} -NoLogo -NoProfile -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass -File ${windowsCommandLiteral(scriptPath)}`;
+}
+function createWrapperContent(runtimeRoot) {
     const cliEntry = path.join(getPackageRoot(), 'dist', 'cli', 'index.js');
     if (!fs.existsSync(cliEntry)) {
         throw new Error(`找不到 EvolCore CLI 入口: ${cliEntry}`);
     }
     const pathValue = process.env.PATH ?? '';
-    const script = [
+    return [
+        WRAPPER_MARKER,
         `$env:EVOLCORE_HOME = ${powershellLiteral(runtimeRoot)}`,
         `$env:Path = ${powershellLiteral(pathValue)}`,
         `& ${powershellLiteral(process.execPath)} --no-warnings=ExperimentalWarning ${powershellLiteral(cliEntry)} start`,
         'exit $LASTEXITCODE',
         '',
     ].join('\r\n');
+}
+function writeWrapper(scriptPath, content) {
     fs.mkdirSync(path.dirname(scriptPath), { recursive: true });
-    fs.writeFileSync(scriptPath, script, 'utf8');
-    return scriptPath;
+    fs.writeFileSync(scriptPath, content, 'utf8');
 }
 function restoreWrapper(file, previous) {
     try {
@@ -76,6 +109,430 @@ function restoreWrapper(file, previous) {
         return error instanceof Error ? error.message : String(error);
     }
 }
+function restoreWrapperUnlessNeeded(file, previous, keepCurrent) {
+    return keepCurrent ? undefined : restoreWrapper(file, previous);
+}
+function writeState(runtimeRoot, backend) {
+    const scriptPath = wrapperPath(runtimeRoot);
+    const state = {
+        $schema_version: WINDOWS_AUTOSTART_STATE_VERSION,
+        backend,
+        wrapperPath: scriptPath,
+        ...(backend === 'task'
+            ? { taskName: WINDOWS_AUTOSTART_TASK_NAME }
+            : { runValueName: WINDOWS_AUTOSTART_RUN_VALUE_NAME }),
+    };
+    try {
+        atomicWriteJson(statePath(runtimeRoot), state);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+function readState(runtimeRoot) {
+    try {
+        const state = atomicReadJson(statePath(runtimeRoot));
+        if (!state || state.$schema_version !== WINDOWS_AUTOSTART_STATE_VERSION)
+            return undefined;
+        if (state.backend !== 'task' && state.backend !== 'user-run')
+            return undefined;
+        if (typeof state.wrapperPath !== 'string' || state.wrapperPath.trim().length === 0)
+            return undefined;
+        if (state.backend === 'task' && state.taskName !== WINDOWS_AUTOSTART_TASK_NAME)
+            return undefined;
+        if (state.backend === 'user-run' && state.runValueName !== WINDOWS_AUTOSTART_RUN_VALUE_NAME)
+            return undefined;
+        return state;
+    }
+    catch {
+        return undefined;
+    }
+}
+function removeState(runtimeRoot) {
+    const file = statePath(runtimeRoot);
+    for (const suffix of ['', '_', '__']) {
+        try {
+            fs.rmSync(file + suffix, { force: true });
+        }
+        catch { }
+    }
+}
+function removeOwnedWrapper(runtimeRoot) {
+    if (wrapperOwnedByEvolCore(runtimeRoot)) {
+        try {
+            fs.rmSync(wrapperPath(runtimeRoot), { force: true });
+        }
+        catch { }
+    }
+}
+function decodeXml(value) {
+    return value
+        .replace(/"/gi, '"')
+        .replace(/'/gi, "'")
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&amp;/gi, '&');
+}
+function xmlElement(xml, name) {
+    const match = xml.match(new RegExp(`<${name}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${name}>`, 'i'));
+    return match ? decodeXml(match[1].trim()) : undefined;
+}
+function xmlBlocks(xml, name) {
+    return [...xml.matchAll(new RegExp(`<${name}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${name}>`, 'gi'))]
+        .map(match => match[1]);
+}
+function normalizeWindowsPath(value) {
+    const trimmed = value.trim().replace(/^"|"$/g, '');
+    return path.win32.normalize(trimmed).toLowerCase();
+}
+function normalizeCommandLine(value) {
+    // Keep whitespace inside quoted paths significant. Collapsing it could make
+    // two different wrapper paths (for example "A  B" and "A B") look equal
+    // and weaken the ownership check used before deletion.
+    return value.trim().toLowerCase();
+}
+function wrapperOwnedByEvolCore(runtimeRoot) {
+    const scriptPath = wrapperPath(runtimeRoot);
+    try {
+        const content = fs.readFileSync(scriptPath, 'utf8');
+        if (content.split(/\r?\n/, 1)[0] === WRAPPER_MARKER)
+            return true;
+        // Recognize wrappers created before the ownership marker was introduced.
+        return content.includes(`$env:EVOLCORE_HOME = ${powershellLiteral(runtimeRoot)}`)
+            && content.includes('--no-warnings=ExperimentalWarning')
+            && content.includes(' start\r\n');
+    }
+    catch {
+        return false;
+    }
+}
+function taskOwnership(xml, runtimeRoot) {
+    const execBlocks = xmlBlocks(xml, 'Exec');
+    if (execBlocks.length !== 1)
+        return { managed: false, current: false };
+    const command = xmlElement(execBlocks[0], 'Command');
+    const args = xmlElement(execBlocks[0], 'Arguments');
+    if (!command || !args)
+        return { managed: false, current: false };
+    const expectedScript = wrapperPath(runtimeRoot);
+    const expectedArgs = taskArguments(expectedScript);
+    const actionMatches = normalizeWindowsPath(command) === normalizeWindowsPath(powershellPath())
+        && normalizeCommandLine(args).includes(normalizeCommandLine(`-File ${windowsCommandLiteral(expectedScript)}`));
+    const state = readState(runtimeRoot);
+    const stateMatches = state?.backend === 'task'
+        && normalizeWindowsPath(state.wrapperPath) === normalizeWindowsPath(expectedScript)
+        && state.taskName === WINDOWS_AUTOSTART_TASK_NAME;
+    const managed = actionMatches && (wrapperOwnedByEvolCore(runtimeRoot) || stateMatches);
+    const principalBlocks = xmlBlocks(xml, 'Principal');
+    const triggerTypes = [...xml.matchAll(/<([A-Za-z]+Trigger)(?:\s[^>]*)?>/gi)]
+        .map(match => match[1].toLowerCase());
+    const runLevel = principalBlocks.length === 1
+        ? xmlElement(principalBlocks[0], 'RunLevel')
+        : undefined;
+    const principalCurrent = principalBlocks.length === 1
+        && /<LogonType>\s*InteractiveToken\s*<\/LogonType>/i.test(principalBlocks[0])
+        // schtasks /RL LIMITED can omit RunLevel entirely because
+        // LeastPrivilege is the schema default.
+        && (runLevel === undefined || /^LeastPrivilege$/i.test(runLevel));
+    const triggerCurrent = triggerTypes.length === 1 && triggerTypes[0] === 'logontrigger';
+    const current = managed
+        && normalizeCommandLine(args) === normalizeCommandLine(expectedArgs)
+        && principalCurrent
+        && triggerCurrent
+        && !/<Enabled>\s*false\s*<\/Enabled>/i.test(xml);
+    return { managed, current };
+}
+function probeWindowsTask(runtimeRoot, action = '启用') {
+    const result = runSchtasks(['/Query', '/TN', WINDOWS_AUTOSTART_TASK_NAME, '/XML']);
+    if (result.status === 0) {
+        const xml = decodeWindowsOutput(result.stdout);
+        const ownership = taskOwnership(xml, runtimeRoot);
+        return { state: 'installed', xml, ...ownership };
+    }
+    const message = resultOutput(result);
+    if (isTaskNotFoundMessage(message))
+        return { state: 'not-found' };
+    return {
+        state: 'error',
+        error: isAccessDenied(result)
+            ? accessDeniedError(action, result)
+            : commandError(result, '查询 Windows 登录自启任务失败'),
+    };
+}
+function parseRegistryValue(output) {
+    const line = output.split(/\r?\n/).find(candidate => (candidate.includes(WINDOWS_AUTOSTART_RUN_VALUE_NAME)
+        && /\bREG_(?:EXPAND_)?SZ\b/i.test(candidate)));
+    if (!line)
+        return undefined;
+    const match = line.match(/\bREG_(?:EXPAND_)?SZ\b\s+([\s\S]+)$/i);
+    return match?.[1]?.trim();
+}
+function probeWindowsRun(runtimeRoot) {
+    const result = runReg(['query', WINDOWS_RUN_KEY, '/v', WINDOWS_AUTOSTART_RUN_VALUE_NAME]);
+    if (result.status === 0) {
+        const command = parseRegistryValue(decodeWindowsOutput(result.stdout));
+        if (!command)
+            return { state: 'error', error: '无法解析 Windows 用户级 Run 自启动项' };
+        const expectedTask = taskCommand(wrapperPath(runtimeRoot));
+        const expectedRun = userRunCommand(wrapperPath(runtimeRoot));
+        const normalizedCommand = normalizeCommandLine(command);
+        const actionMatches = normalizedCommand === normalizeCommandLine(expectedTask)
+            || normalizedCommand === normalizeCommandLine(expectedRun);
+        const state = readState(runtimeRoot);
+        const stateMatches = state?.backend === 'user-run'
+            && normalizeWindowsPath(state.wrapperPath) === normalizeWindowsPath(wrapperPath(runtimeRoot))
+            && state.runValueName === WINDOWS_AUTOSTART_RUN_VALUE_NAME;
+        const managed = actionMatches && (wrapperOwnedByEvolCore(runtimeRoot) || stateMatches);
+        const current = normalizedCommand === normalizeCommandLine(expectedRun);
+        return { state: 'installed', command, managed, current };
+    }
+    const message = resultOutput(result);
+    if (isRegistryValueNotFoundMessage(message))
+        return { state: 'not-found' };
+    return { state: 'error', error: commandError(result, '查询 Windows 用户级 Run 自启动项失败') };
+}
+function deleteManagedTask(runtimeRoot) {
+    // Re-query immediately before deletion so a same-named task that was
+    // replaced after an earlier probe is not deleted based on stale ownership.
+    const task = probeWindowsTask(runtimeRoot, '禁用');
+    if (task.state === 'error')
+        return task;
+    if (task.state === 'not-found')
+        return { state: 'not-found' };
+    if (!task.managed)
+        return { state: 'preserved' };
+    const result = runSchtasks(['/Delete', '/TN', WINDOWS_AUTOSTART_TASK_NAME, '/F']);
+    if (result.status === 0)
+        return { state: 'deleted' };
+    return {
+        state: 'error',
+        error: isAccessDenied(result)
+            ? accessDeniedError('禁用', result)
+            : commandError(result, '删除 Windows 登录自启任务失败'),
+    };
+}
+function deleteManagedRun(runtimeRoot) {
+    // reg delete operates only by value name. Re-query the command first to
+    // avoid deleting a value another program installed after our earlier probe.
+    const run = probeWindowsRun(runtimeRoot);
+    if (run.state === 'error')
+        return run;
+    if (run.state === 'not-found')
+        return { state: 'not-found' };
+    if (!run.managed)
+        return { state: 'preserved' };
+    const result = runReg(['delete', WINDOWS_RUN_KEY, '/v', WINDOWS_AUTOSTART_RUN_VALUE_NAME, '/f']);
+    if (result.status === 0)
+        return { state: 'deleted' };
+    return { state: 'error', error: commandError(result, '删除 Windows 用户级 Run 自启动项失败') };
+}
+function createUserRunAutostart(runtimeRoot, scriptPath, wrapperWasCurrent) {
+    // Query again immediately before the /f write. This cannot make the
+    // registry update fully atomic, but it narrows the window in which a
+    // same-named value owned by another program could be overwritten.
+    const existing = probeWindowsRun(runtimeRoot);
+    if (existing.state === 'error')
+        return { ok: false, enabled: false, error: existing.error };
+    if (existing.state === 'installed' && !existing.managed) {
+        return {
+            ok: false,
+            enabled: false,
+            error: `HKCU Run 中已存在同名值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME}，但其命令不属于 EvolCore；为避免覆盖已停止配置。`,
+        };
+    }
+    if (existing.state === 'installed' && existing.managed && existing.current) {
+        const stateError = writeState(runtimeRoot, 'user-run');
+        if (stateError)
+            return { ok: false, enabled: true, backend: 'user-run', error: `记录自启动后端失败: ${stateError}` };
+        return {
+            ok: true,
+            enabled: true,
+            backend: 'user-run',
+            ...(wrapperWasCurrent ? { unchanged: true } : {}),
+        };
+    }
+    const result = runReg([
+        'add', WINDOWS_RUN_KEY,
+        '/v', WINDOWS_AUTOSTART_RUN_VALUE_NAME,
+        '/t', 'REG_SZ',
+        '/d', userRunCommand(scriptPath),
+        '/f',
+    ]);
+    if (result.status !== 0) {
+        return {
+            ok: false,
+            enabled: existing.state === 'installed' && existing.managed,
+            ...(existing.state === 'installed' && existing.managed ? { backend: 'user-run' } : {}),
+            error: commandError(result, '创建 Windows 用户级 Run 自启动项失败'),
+        };
+    }
+    const verified = probeWindowsRun(runtimeRoot);
+    if (verified.state === 'error') {
+        return {
+            ok: false,
+            enabled: true,
+            backend: 'user-run',
+            error: `HKCU Run 写入命令已成功，但验证查询失败，当前状态不确定；已保留 EvolCore 启动脚本，请重试 ec init --auto-start。${verified.error}`,
+        };
+    }
+    if (verified.state === 'not-found') {
+        return { ok: false, enabled: false, error: 'HKCU Run 写入命令已成功，但验证时未找到该自启动项' };
+    }
+    if (!verified.managed) {
+        return {
+            ok: false,
+            enabled: false,
+            error: `HKCU Run 写入后同名值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME} 已变为非 EvolCore 命令；为避免误删已保留该值。`,
+        };
+    }
+    if (!verified.current) {
+        return {
+            ok: false,
+            enabled: true,
+            backend: 'user-run',
+            error: 'HKCU Run 自启动项已写入，但验证到的命令与当前 EvolCore 配置不一致；已保留启动脚本，请重试 ec init --auto-start。',
+        };
+    }
+    const stateError = writeState(runtimeRoot, 'user-run');
+    if (stateError)
+        return { ok: false, enabled: true, backend: 'user-run', error: `记录自启动后端失败: ${stateError}` };
+    return { ok: true, enabled: true, backend: 'user-run' };
+}
+function currentBackend(runtimeRoot) {
+    const savedState = readState(runtimeRoot);
+    const task = probeWindowsTask(runtimeRoot);
+    if (task.state === 'installed' && task.current)
+        return 'task';
+    if (task.state === 'error' && savedState?.backend === 'task')
+        return 'task';
+    const run = probeWindowsRun(runtimeRoot);
+    if (run.state === 'installed' && run.managed && run.current)
+        return 'user-run';
+    if (run.state === 'error' && savedState?.backend === 'user-run')
+        return 'user-run';
+    return undefined;
+}
+export function windowsAutostartInstalled(runtimeRoot = resolvePaths().root) {
+    if (!isWindows())
+        return false;
+    return currentBackend(path.resolve(runtimeRoot)) !== undefined;
+}
+function disableWindowsAutostart(runtimeRoot) {
+    const savedState = readState(runtimeRoot);
+    const task = probeWindowsTask(runtimeRoot, '禁用');
+    if (task.state === 'error') {
+        // HKCU remains writable from a normal terminal. Clean a Run value whose
+        // ownership can still be verified, but keep the wrapper and state because
+        // the task backend is unknown until an elevated retry succeeds.
+        const run = probeWindowsRun(runtimeRoot);
+        if (run.state === 'error') {
+            return {
+                ok: false,
+                enabled: true,
+                ...(savedState?.backend ? { backend: savedState.backend } : {}),
+                error: `${task.error}；${run.error}`,
+            };
+        }
+        if (run.state === 'installed' && !run.managed) {
+            return { ok: false, enabled: true, error: `HKCU Run 中的同名值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME} 已被其他命令占用；为避免误删已保留。${task.error}` };
+        }
+        if (run.state === 'installed' && run.managed) {
+            const removeRun = deleteManagedRun(runtimeRoot);
+            if (removeRun.state === 'error')
+                return { ok: false, enabled: true, backend: 'user-run', error: removeRun.error };
+            if (removeRun.state === 'preserved') {
+                return {
+                    ok: false,
+                    enabled: true,
+                    error: `HKCU Run 中的同名值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME} 在删除前已被其他命令替换；为避免误删已保留。${task.error}`,
+                };
+            }
+        }
+        return { ok: false, enabled: true, error: `用户级 Run 自启动已删除或不存在，但无法确认是否存在计划任务。${task.error}` };
+    }
+    const run = probeWindowsRun(runtimeRoot);
+    if (run.state === 'error') {
+        return {
+            ok: false,
+            enabled: true,
+            ...(task.state === 'installed' && task.managed ? { backend: 'task' } : {}),
+            error: run.error,
+        };
+    }
+    const preserved = [];
+    if (task.state === 'installed' && !task.managed)
+        preserved.push(`计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME}`);
+    if (run.state === 'installed' && !run.managed)
+        preserved.push(`HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME}`);
+    if (task.state === 'installed' && !task.managed && run.state === 'installed' && run.managed) {
+        const removeRun = deleteManagedRun(runtimeRoot);
+        if (removeRun.state === 'error') {
+            return { ok: false, enabled: true, backend: 'user-run', error: removeRun.error };
+        }
+        if (removeRun.state === 'preserved')
+            preserved.push(`删除前被替换的 HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME}`);
+        if (removeRun.state !== 'preserved')
+            removeOwnedWrapper(runtimeRoot);
+        removeState(runtimeRoot);
+        return {
+            ok: true,
+            enabled: false,
+            warning: `已禁用 EvolCore 管理的自启动；检测到同名但并非 EvolCore 管理的 ${preserved.join('、')}，为避免误删已保留。`,
+        };
+    }
+    if (run.state === 'installed' && !run.managed && task.state === 'installed' && task.managed) {
+        const removeTask = deleteManagedTask(runtimeRoot);
+        if (removeTask.state === 'error') {
+            return { ok: false, enabled: true, backend: 'task', error: removeTask.error };
+        }
+        if (removeTask.state === 'preserved')
+            preserved.push(`删除前被替换的计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME}`);
+        if (removeTask.state !== 'preserved')
+            removeOwnedWrapper(runtimeRoot);
+        removeState(runtimeRoot);
+        return {
+            ok: true,
+            enabled: false,
+            warning: `已禁用 EvolCore 管理的自启动；检测到同名但并非 EvolCore 管理的 ${preserved.join('、')}，为避免误删已保留。`,
+        };
+    }
+    if (task.state === 'installed' && task.managed) {
+        const result = deleteManagedTask(runtimeRoot);
+        if (result.state === 'error') {
+            return {
+                ok: false,
+                enabled: true,
+                backend: 'task',
+                error: result.error,
+            };
+        }
+        if (result.state === 'preserved')
+            preserved.push(`删除前被替换的计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME}`);
+    }
+    if (run.state === 'installed' && run.managed) {
+        const result = deleteManagedRun(runtimeRoot);
+        if (result.state === 'error') {
+            return {
+                ok: false,
+                enabled: true,
+                backend: 'user-run',
+                error: result.error,
+            };
+        }
+        if (result.state === 'preserved')
+            preserved.push(`删除前被替换的 HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME}`);
+    }
+    removeOwnedWrapper(runtimeRoot);
+    removeState(runtimeRoot);
+    return {
+        ok: true,
+        enabled: false,
+        ...(preserved.length > 0
+            ? { warning: `检测到同名但并非 EvolCore 管理的 ${preserved.join('、')}，为避免误删已保留。` }
+            : {}),
+    };
+}
 export function configureWindowsAutostart(enabled, runtimeRoot) {
     if (!isWindows()) {
         return {
@@ -85,87 +542,287 @@ export function configureWindowsAutostart(enabled, runtimeRoot) {
         };
     }
     const absoluteRoot = path.resolve(runtimeRoot);
+    if (!enabled)
+        return disableWindowsAutostart(absoluteRoot);
     const scriptPath = wrapperPath(absoluteRoot);
-    if (!enabled) {
-        const result = runSchtasks(['/Delete', '/TN', WINDOWS_AUTOSTART_TASK_NAME, '/F']);
-        if (result.status !== 0) {
-            const probe = probeWindowsTask();
-            if (probe.state === 'not-found') {
-                try {
-                    fs.rmSync(scriptPath, { force: true });
-                }
-                catch { }
-                return { ok: true, enabled: false };
+    let desiredContent;
+    try {
+        desiredContent = createWrapperContent(absoluteRoot);
+    }
+    catch (error) {
+        return { ok: false, enabled: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    const previousTask = probeWindowsTask(absoluteRoot);
+    if (previousTask.state === 'error') {
+        const savedState = readState(absoluteRoot);
+        return {
+            ok: false,
+            enabled: savedState !== undefined,
+            ...(savedState ? { backend: savedState.backend } : {}),
+            error: previousTask.error,
+        };
+    }
+    if (previousTask.state === 'installed' && !previousTask.managed) {
+        return {
+            ok: false,
+            enabled: false,
+            error: `已存在同名计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME}，但其启动命令不属于 EvolCore；为避免覆盖已停止配置。`,
+        };
+    }
+    let previousWrapper;
+    try {
+        if (fs.existsSync(scriptPath))
+            previousWrapper = fs.readFileSync(scriptPath, 'utf8');
+    }
+    catch (error) {
+        return {
+            ok: false,
+            enabled: previousTask.state === 'installed' && previousTask.managed,
+            ...(previousTask.state === 'installed' && previousTask.managed ? { backend: 'task' } : {}),
+            error: `读取 Windows 登录自启脚本失败：${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    const wrapperCurrent = previousWrapper === desiredContent;
+    const existingRun = probeWindowsRun(absoluteRoot);
+    if (existingRun.state === 'error') {
+        const savedState = readState(absoluteRoot);
+        const knownBackend = previousTask.state === 'installed' && previousTask.managed
+            ? 'task'
+            : savedState?.backend;
+        return {
+            ok: false,
+            enabled: knownBackend !== undefined,
+            ...(knownBackend ? { backend: knownBackend } : {}),
+            error: existingRun.error,
+        };
+    }
+    if (previousTask.state === 'installed' && previousTask.current) {
+        if (!wrapperCurrent) {
+            try {
+                writeWrapper(scriptPath, desiredContent);
+            }
+            catch (error) {
+                const restoreError = restoreWrapper(scriptPath, previousWrapper);
+                const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+                return {
+                    ok: false,
+                    enabled: true,
+                    backend: 'task',
+                    error: `更新 Windows 登录自启脚本失败：${error instanceof Error ? error.message : String(error)}${rollbackSuffix}`,
+                };
+            }
+        }
+        let removedManagedRun = false;
+        let warning;
+        if (existingRun.state === 'installed' && existingRun.managed) {
+            const removeRun = deleteManagedRun(absoluteRoot);
+            if (removeRun.state === 'error') {
+                const stateError = writeState(absoluteRoot, 'task');
+                const stateSuffix = stateError ? `；记录当前 task 后端失败：${stateError}` : '';
+                return {
+                    ok: false,
+                    enabled: true,
+                    backend: 'task',
+                    error: `计划任务配置未变化，但无法清理残留的用户级 Run 自启动项：${removeRun.error}${stateSuffix}`,
+                };
+            }
+            removedManagedRun = removeRun.state === 'deleted';
+            if (removeRun.state === 'preserved') {
+                warning = `HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME} 在清理前已被其他命令替换；为避免误删已保留。`;
+            }
+        }
+        else if (existingRun.state === 'installed') {
+            warning = `检测到同名但并非 EvolCore 管理的 HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME}，为避免误删已保留。`;
+        }
+        const stateError = writeState(absoluteRoot, 'task');
+        if (stateError)
+            return { ok: false, enabled: true, backend: 'task', error: `记录自启动后端失败: ${stateError}` };
+        return {
+            ok: true,
+            enabled: true,
+            backend: 'task',
+            ...(!wrapperCurrent || removedManagedRun ? {} : { unchanged: true }),
+            ...(warning ? { warning } : {}),
+        };
+    }
+    if (previousWrapper !== undefined
+        && !wrapperOwnedByEvolCore(absoluteRoot)
+        && !(previousTask.state === 'installed' && previousTask.managed)
+        && !(existingRun.state === 'installed' && existingRun.managed)) {
+        return {
+            ok: false,
+            enabled: false,
+            error: `启动脚本 ${scriptPath} 已存在但不属于 EvolCore；为避免覆盖已停止配置。`,
+        };
+    }
+    try {
+        writeWrapper(scriptPath, desiredContent);
+    }
+    catch (error) {
+        const restoreError = restoreWrapper(scriptPath, previousWrapper);
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        return {
+            ok: false,
+            enabled: previousTask.state === 'installed' && previousTask.managed,
+            ...(previousTask.state === 'installed' && previousTask.managed ? { backend: 'task' } : {}),
+            error: `写入 Windows 登录自启脚本失败：${error instanceof Error ? error.message : String(error)}${rollbackSuffix}`,
+        };
+    }
+    const taskBeforeCreate = probeWindowsTask(absoluteRoot);
+    if (taskBeforeCreate.state === 'error') {
+        const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, previousTask.state === 'installed' || (existingRun.state === 'installed' && existingRun.managed));
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        return {
+            ok: false,
+            enabled: previousTask.state === 'installed' && previousTask.managed,
+            ...(previousTask.state === 'installed' && previousTask.managed ? { backend: 'task' } : {}),
+            error: `创建计划任务前的复核失败：${taskBeforeCreate.error}${rollbackSuffix}`,
+        };
+    }
+    if (taskBeforeCreate.state === 'installed' && !taskBeforeCreate.managed) {
+        const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, existingRun.state === 'installed' && existingRun.managed);
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        return {
+            ok: false,
+            enabled: false,
+            error: `计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME} 在创建前已被其他配置占用；为避免覆盖已停止配置${rollbackSuffix}`,
+        };
+    }
+    const args = [
+        '/Create',
+        '/TN', WINDOWS_AUTOSTART_TASK_NAME,
+        '/SC', 'ONLOGON',
+        '/TR', taskCommand(scriptPath),
+        '/RL', 'LIMITED',
+        '/F',
+    ];
+    const result = runSchtasks(args);
+    if (result.status !== 0) {
+        if (isAccessDenied(result) && taskBeforeCreate.state === 'not-found') {
+            const fallback = createUserRunAutostart(absoluteRoot, scriptPath, wrapperCurrent);
+            const fallbackMayBeInstalled = fallback.enabled && fallback.backend === 'user-run';
+            const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, fallback.ok || fallbackMayBeInstalled || (existingRun.state === 'installed' && existingRun.managed));
+            if (fallback.ok) {
+                return {
+                    ...fallback,
+                    warning: '任务计划程序拒绝访问，已回退到当前用户 HKCU Run 自启动（无需管理员权限）。如需改用计划任务，请以管理员身份再次运行 ec init --auto-start。',
+                };
             }
+            const fallbackError = fallback.error ? `；用户级 Run 回退失败：${fallback.error}` : '';
+            const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
             return {
                 ok: false,
-                enabled: probe.state === 'installed',
-                error: commandError(result, '删除 Windows 开机自启任务失败'),
+                enabled: fallback.enabled,
+                ...(fallback.backend ? { backend: fallback.backend } : {}),
+                error: `${accessDeniedError('启用', result)}${fallbackError}${rollbackSuffix}`,
             };
         }
-        try {
-            fs.rmSync(scriptPath, { force: true });
-        }
-        catch { }
-        return { ok: true, enabled: false };
+        const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, taskBeforeCreate.state === 'installed' || (existingRun.state === 'installed' && existingRun.managed));
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        const previousBackend = taskBeforeCreate.state === 'installed'
+            ? 'task'
+            : existingRun.state === 'installed' && existingRun.managed
+                ? 'user-run'
+                : undefined;
+        return {
+            ok: false,
+            enabled: previousBackend !== undefined,
+            ...(previousBackend ? { backend: previousBackend } : {}),
+            error: `${isAccessDenied(result)
+                ? accessDeniedError('启用', result)
+                : commandError(result, '创建 Windows 登录自启任务失败')}${rollbackSuffix}`,
+        };
     }
-    let previousWrapper;
-    let previouslyInstalled = false;
-    try {
-        if (fs.existsSync(scriptPath))
-            previousWrapper = fs.readFileSync(scriptPath, 'utf8');
-        const previousTask = probeWindowsTask();
-        if (previousTask.state === 'error') {
-            return { ok: false, enabled: false, error: previousTask.error };
-        }
-        previouslyInstalled = previousTask.state === 'installed';
-        const taskScript = createWrapper(absoluteRoot);
-        const systemRoot = process.env.SystemRoot || 'C:\\Windows';
-        const powershell = path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
-        const taskCommand = `${windowsCommandLiteral(powershell)} -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File ${windowsCommandLiteral(taskScript)}`;
-        // Omitting /RU keeps the task attached to the user creating it and avoids a password prompt.
-        const args = [
-            '/Create',
-            '/TN', WINDOWS_AUTOSTART_TASK_NAME,
-            '/SC', 'ONLOGON',
-            '/TR', taskCommand,
-            '/RL', 'LIMITED',
-            '/F',
-        ];
-        const result = runSchtasks(args);
-        if (result.status !== 0) {
-            const restoreError = restoreWrapper(scriptPath, previousWrapper);
-            const probe = probeWindowsTask();
-            const rollbackSuffix = restoreError ? `; 恢复原启动脚本失败: ${restoreError}` : '';
+    const verified = probeWindowsTask(absoluteRoot);
+    if (verified.state === 'error') {
+        return {
+            ok: false,
+            enabled: true,
+            backend: 'task',
+            error: `schtasks /Create 已成功，但验证查询失败，当前状态不确定；已保留 EvolCore 启动脚本，请以管理员身份重试 ec init --auto-start。${verified.error}`,
+        };
+    }
+    if (verified.state === 'not-found') {
+        const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, existingRun.state === 'installed' && existingRun.managed);
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        const runStillEnabled = existingRun.state === 'installed' && existingRun.managed;
+        return {
+            ok: false,
+            enabled: runStillEnabled,
+            ...(runStillEnabled ? { backend: 'user-run' } : {}),
+            error: `schtasks /Create 已成功，但验证时未找到 EvolCore 计划任务${rollbackSuffix}`,
+        };
+    }
+    if (!verified.managed) {
+        const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, existingRun.state === 'installed' && existingRun.managed);
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        const runStillEnabled = existingRun.state === 'installed' && existingRun.managed;
+        return {
+            ok: false,
+            enabled: runStillEnabled,
+            ...(runStillEnabled ? { backend: 'user-run' } : {}),
+            error: `计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME} 在创建后已变为非 EvolCore 配置；为避免误删已保留该任务${rollbackSuffix}`,
+        };
+    }
+    if (!verified.current) {
+        if (previousTask.state === 'installed') {
             return {
                 ok: false,
-                enabled: probe.state === 'installed',
-                error: `${commandError(result, '创建 Windows 开机自启任务失败')}${rollbackSuffix}`,
+                enabled: true,
+                backend: 'task',
+                error: '更新后的 EvolCore 计划任务仍与当前配置不一致；为避免破坏原任务，已保留任务和启动脚本，请以管理员身份重试 ec init --auto-start。',
             };
         }
-        const probe = probeWindowsTask();
-        if (probe.state !== 'installed') {
-            const cleanup = runSchtasks(['/Delete', '/TN', WINDOWS_AUTOSTART_TASK_NAME, '/F']);
-            const afterCleanup = cleanup.status === 0 ? probeWindowsTask() : probe;
-            const restoreError = restoreWrapper(scriptPath, previousWrapper);
-            const details = probe.state === 'error' ? probe.error : '创建后无法查询到任务';
-            const cleanupError = cleanup.status === 0 ? '' : `; 清理任务失败: ${commandError(cleanup, '未知错误')}`;
-            const rollbackSuffix = restoreError ? `; 恢复原启动脚本失败: ${restoreError}` : '';
+        const cleanup = deleteManagedTask(absoluteRoot);
+        if (cleanup.state === 'error') {
             return {
                 ok: false,
-                enabled: afterCleanup.state === 'installed',
-                error: `${details}${cleanupError}${rollbackSuffix}`,
+                enabled: true,
+                backend: 'task',
+                error: `创建后的 EvolCore 计划任务与当前配置不一致，且清理失败：${cleanup.error}；已保留启动脚本。`,
             };
         }
-        return { ok: true, enabled: true };
-    }
-    catch (error) {
-        const restoreError = restoreWrapper(scriptPath, previousWrapper);
-        const rollbackSuffix = restoreError ? `; 恢复原启动脚本失败: ${restoreError}` : '';
+        if (cleanup.state === 'preserved') {
+            const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, existingRun.state === 'installed' && existingRun.managed);
+            const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+            return {
+                ok: false,
+                enabled: false,
+                error: `计划任务 \\${WINDOWS_AUTOSTART_TASK_NAME} 在回滚前已被其他配置替换；为避免误删已保留该任务${rollbackSuffix}`,
+            };
+        }
+        const restoreError = restoreWrapperUnlessNeeded(scriptPath, previousWrapper, existingRun.state === 'installed' && existingRun.managed);
+        const rollbackSuffix = restoreError ? `；恢复原启动脚本失败：${restoreError}` : '';
+        const runStillEnabled = existingRun.state === 'installed' && existingRun.managed;
         return {
             ok: false,
-            enabled: previouslyInstalled,
-            error: `${error instanceof Error ? error.message : String(error)}${rollbackSuffix}`,
+            enabled: runStillEnabled,
+            ...(runStillEnabled ? { backend: 'user-run' } : {}),
+            error: `创建后的 EvolCore 计划任务与当前配置不一致，已安全清理${rollbackSuffix}`,
         };
     }
+    let warning;
+    if (existingRun.state === 'installed' && existingRun.managed) {
+        const removeRun = deleteManagedRun(absoluteRoot);
+        if (removeRun.state === 'error') {
+            const stateError = writeState(absoluteRoot, 'task');
+            const stateSuffix = stateError ? `；记录当前 task 后端失败：${stateError}` : '';
+            return {
+                ok: false,
+                enabled: true,
+                backend: 'task',
+                error: `计划任务已创建并验证成功，但无法清理原用户级 Run 自启动项：${removeRun.error}；已保留任务和启动脚本，请重试 ec init --auto-start。${stateSuffix}`,
+            };
+        }
+        if (removeRun.state === 'preserved') {
+            warning = `HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME} 在清理前已被其他命令替换；为避免误删已保留。`;
+        }
+    }
+    else if (existingRun.state === 'installed') {
+        warning = `检测到同名但并非 EvolCore 管理的 HKCU Run 值 ${WINDOWS_AUTOSTART_RUN_VALUE_NAME}，为避免误删已保留。`;
+    }
+    const stateError = writeState(absoluteRoot, 'task');
+    if (stateError)
+        return { ok: false, enabled: true, backend: 'task', error: `记录自启动后端失败: ${stateError}` };
+    return { ok: true, enabled: true, backend: 'task', ...(warning ? { warning } : {}) };
 }