evolcore 0.0.7 → 0.0.9

package/dist/ipc.js

@@ -247,6 +247,8 @@ export class IpcServer {
         return roots;
     }
     start() {
+        if (this.server)
+            return Promise.resolve();
         // Remove stale socket file (Unix only — named pipes auto-cleanup on process exit)
         if (!isNamedPipe(this.socketPath)) {
             try {
@@ -517,7 +519,7 @@ export class IpcServer {
                         mentions: Array.isArray(cmd.mentions)
                             ? cmd.mentions.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry))
                             : undefined,
-                        encrypt: cmd.encrypt === true,
+                        encrypt: typeof cmd.encrypt === 'boolean' ? cmd.encrypt : undefined,
                         thread: typeof cmd.thread === 'string' ? cmd.thread : undefined,
                         returnPolicy: cmd.returnPolicy === 'required' || cmd.returnPolicy === 'none' ? cmd.returnPolicy : undefined,
                         originSessionId: typeof cmd.originSessionId === 'string' ? cmd.originSessionId : undefined,

package/dist/product.js

@@ -10,6 +10,7 @@ export const MAIN_CLI_BIN = 'ec';
 export const WEB_PACKAGE_NAME = 'ec-web';
 export const WEB_CLI_BIN = 'ec-web';
 export const WEB_PACKAGE_LATEST = `${WEB_PACKAGE_NAME}@latest`;
+export const MIN_ECWEB_VERSION = '0.0.8';
 export const DAEMON_CONFIG_FILENAME = 'daemon.json';
 export const DAEMON_SCHEMA_NAME = 'daemon';
 export const RUNTIME_HOME_ENV = 'EVOLCORE_HOME';

package/dist/utils/autostart.js

@@ -0,0 +1,27 @@
+import { configureMacosAutostart, macosAutostartInstalled } from './macos-autostart.js';
+import { configureWindowsAutostart, windowsAutostartInstalled } from './windows-autostart.js';
+export function autostartInstalled() {
+    if (process.platform === 'win32')
+        return windowsAutostartInstalled();
+    if (process.platform === 'darwin')
+        return macosAutostartInstalled();
+    return false;
+}
+export function configureAutostart(enabled, runtimeRoot) {
+    if (process.platform === 'win32')
+        return configureWindowsAutostart(enabled, runtimeRoot);
+    if (process.platform === 'darwin')
+        return configureMacosAutostart(enabled, runtimeRoot);
+    return {
+        ok: !enabled,
+        enabled: false,
+        ...(!enabled ? {} : { error: '登录自启仅支持 Windows 和 macOS 主机' }),
+    };
+}
+export function autostartPlatformLabel() {
+    if (process.platform === 'win32')
+        return 'Windows';
+    if (process.platform === 'darwin')
+        return 'macOS';
+    return undefined;
+}

package/dist/utils/codex-cli.js

@@ -0,0 +1,39 @@
+import { execFileSync } from 'child_process';
+import { isWindows, resolveCommandPath } from './cross-platform.js';
+/**
+ * Resolve the installed Codex CLI entrypoint. npm creates a `.cmd` shim on
+ * Windows, which is not the same executable as the extensionless Unix shim.
+ */
+export function resolveCodexCliPath() {
+    return resolveCommandPath('codex');
+}
+/**
+ * Build a child-process invocation that works for npm's Windows command shim.
+ * The options are injectable so platform-specific behavior can be tested on
+ * non-Windows CI hosts.
+ */
+export function resolveCodexLaunchCommand(args, options = {}) {
+    const windows = options.isWindows ?? isWindows;
+    const commandPath = options.commandPath !== undefined
+        ? options.commandPath
+        : resolveCodexCliPath();
+    if (!commandPath)
+        return null;
+    if (windows && /\.(cmd|bat)$/i.test(commandPath)) {
+        return {
+            command: options.comSpec ?? process.env.ComSpec ?? 'cmd.exe',
+            args: ['/d', '/s', '/c', commandPath, ...args],
+        };
+    }
+    return { command: commandPath, args };
+}
+/** Execute a Codex CLI command using the resolved npm shim/path. */
+export function execCodexCliSync(args, options) {
+    const commandPath = resolveCodexCliPath();
+    if (!commandPath)
+        throw new Error('Codex CLI not found');
+    const launchCommand = resolveCodexLaunchCommand(args, { commandPath });
+    if (!launchCommand)
+        throw new Error('Codex CLI not found');
+    return execFileSync(launchCommand.command, launchCommand.args, options);
+}

package/dist/utils/cross-platform.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'url';
 import { execFileSync, execFile, spawn, spawnSync } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs';
-import { getProcessStartTime } from './process-introspect.js';
+import { getProcessStartTime, parseCimDate } from './process-introspect.js';
 const execFileAsync = promisify(execFile);
 export const isWindows = process.platform === 'win32';
 const ENCODE_PATH_MAX = 200;
@@ -38,6 +38,10 @@ export function encodePath(projectPath) {
  * Cross-platform process liveness check.
  */
 export function isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (isWindows)
+        return isWindowsProcessRunning(pid);
     try {
         process.kill(pid, 0);
         return true;
@@ -47,23 +51,65 @@ export function isProcessRunning(pid) {
         return e.code === 'EPERM';
     }
 }
+function isWindowsProcessRunning(pid) {
+    try {
+        const result = spawnSync('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], { encoding: 'utf-8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        if (result.status === 0 && new RegExp(`,"${pid}",`, 'i').test(result.stdout || ''))
+            return true;
+    }
+    catch { }
+    // Keep a conservative fallback for restricted Windows environments where
+    // tasklist is unavailable. A failed probe must never be treated as proof of
+    // process exit by lifecycle code.
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === 'EPERM';
+    }
+}
 /**
  * Cross-platform process termination.
  */
 export function killProcess(pid, force = false) {
-    if (isWindows && force) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (isWindows) {
         try {
-            spawnSync('taskkill', ['/PID', String(pid), '/F'], { windowsHide: true });
+            const args = ['/PID', String(pid), '/T'];
+            if (force)
+                args.push('/F');
+            const result = spawnSync('taskkill', args, {
+                encoding: 'utf-8',
+                timeout: 10_000,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+            return result.status === 0 || !isProcessRunning(pid);
         }
-        catch { }
-    }
-    else {
-        try {
-            process.kill(pid, force ? 'SIGKILL' : 'SIGTERM');
+        catch {
+            return !isProcessRunning(pid);
         }
-        catch { }
+    }
+    try {
+        process.kill(pid, force ? 'SIGKILL' : 'SIGTERM');
+        return true;
+    }
+    catch {
+        return !isProcessRunning(pid);
     }
 }
+/** Wait until a process has really disappeared from the host process table. */
+export async function waitForProcessExit(pid, timeoutMs = 10_000, intervalMs = 250) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid))
+            return true;
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    return !isProcessRunning(pid);
+}
 /**
  * Cross-platform process search by command line pattern.
  * Returns list of matching PIDs.
@@ -71,11 +117,37 @@ export function killProcess(pid, force = false) {
 export function findProcesses(pattern) {
     try {
         if (isWindows) {
-            const result = spawnSync('wmic', ['process', 'where', `CommandLine like '%${pattern}%'`, 'get', 'ProcessId'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
-            const output = result.stdout || '';
-            return output.split('\n')
-                .map(line => parseInt(line.trim(), 10))
-                .filter(pid => !isNaN(pid) && pid !== process.pid);
+            // WMI LIKE is wildcard matching, not JavaScript regex matching. Query a
+            // stable literal anchor first, then apply the requested regex locally.
+            const anchor = windowsProcessSearchAnchor(pattern);
+            const escapedAnchor = anchor.replace(/'/g, "''");
+            const script = `$a='${escapedAnchor}'; Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and $_.CommandLine -like ('*' + $a + '*') } | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress`;
+            const result = spawnSync('powershell', ['-NoProfile', '-Command', script], { encoding: null, timeout: 8000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+            const raw = decodeWindowsOutput(result.stdout).trim();
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                const rows = !parsed ? [] : Array.isArray(parsed) ? parsed : [parsed];
+                const matcherCandidates = [pattern, pattern.replace(/\\\\/g, '\\')]
+                    .filter((value, index, values) => values.indexOf(value) === index)
+                    .map((value) => {
+                    try {
+                        return new RegExp(value, 'i');
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((value) => value !== null);
+                return rows
+                    .filter(row => Number.isInteger(row.ProcessId) && row.ProcessId !== process.pid)
+                    .filter(row => {
+                    const commandLine = row.CommandLine || '';
+                    const normalized = commandLine.replace(/\\/g, '/');
+                    return matcherCandidates.some(matcher => matcher.test(commandLine) || matcher.test(normalized));
+                })
+                    .map(row => row.ProcessId);
+            }
+            return [];
         }
         else {
             const output = execFileSync('pgrep', ['-f', pattern], { encoding: 'utf-8' }).trim();
@@ -86,6 +158,10 @@ export function findProcesses(pattern) {
         return [];
     }
 }
+function windowsProcessSearchAnchor(pattern) {
+    const tokens = pattern.match(/[A-Za-z0-9][A-Za-z0-9._-]{2,}/g) || [];
+    return tokens.sort((a, b) => b.length - a.length)[0] || pattern;
+}
 /**
  * Cross-platform: find PIDs listening on a TCP port.
  * Used to clean up stale/orphaned listeners (e.g. manually-spawned ecweb
@@ -124,13 +200,35 @@ export function findProcessByPort(port) {
 export function getProcessInfo(pid) {
     try {
         if (isWindows) {
+            // WMIC was removed from recent Windows installations. Prefer the
+            // supported CIM API and keep WMIC as a compatibility fallback.
+            const psScript = `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' | Select-Object WorkingSetSize,CreationDate | ConvertTo-Json -Compress)`;
+            const ps = spawnSync('powershell', ['-NoProfile', '-Command', psScript], {
+                encoding: null, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true,
+            });
+            const raw = decodeWindowsOutput(ps.stdout).trim();
+            if (raw) {
+                const processInfo = JSON.parse(raw);
+                const memory = Number(processInfo.WorkingSetSize);
+                const createdAt = processInfo.CreationDate
+                    ? parseCimDate(processInfo.CreationDate) ?? parseDateString(processInfo.CreationDate)
+                    : null;
+                return {
+                    ...(Number.isFinite(memory) && memory > 0 ? { memory: String(Math.round(memory / 1024)) } : {}),
+                    ...(createdAt !== null ? { uptime: formatUptime(Math.max(0, Math.floor((Date.now() - createdAt) / 1000))) } : {}),
+                };
+            }
             const result = spawnSync('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'WorkingSetSize,CreationDate'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
             const output = result.stdout || '';
             const lines = output.trim().split('\n').filter(l => l.trim());
             if (lines.length >= 2) {
                 const parts = lines[1].trim().split(/\s+/);
                 const memKB = parts[1] ? Math.round(parseInt(parts[1], 10) / 1024) : undefined;
-                return { memory: memKB ? `${memKB}` : undefined };
+                const createdAt = parts[0] ? parseCimDate(parts[0]) ?? parseDateString(parts[0]) : null;
+                return {
+                    ...(memKB ? { memory: `${memKB}` } : {}),
+                    ...(createdAt !== null ? { uptime: formatUptime(Math.max(0, Math.floor((Date.now() - createdAt) / 1000))) } : {}),
+                };
             }
         }
         else {
@@ -167,6 +265,37 @@ function formatUptime(totalSeconds) {
         parts.push(`${seconds}s`);
     return parts.join(' ');
 }
+function parseDateString(value) {
+    const microsoftJsonDate = value.match(/^\\?\/Date\(([-+]?\d+)\)\\?\/$/);
+    if (microsoftJsonDate)
+        return Number(microsoftJsonDate[1]);
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+/** Decode PowerShell output consistently across Windows 5.1 and pwsh. */
+function decodeWindowsOutput(value) {
+    if (!value)
+        return '';
+    const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return bytes.subarray(2).toString('utf16le');
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        const swapped = Buffer.allocUnsafe(bytes.length - 2);
+        for (let i = 2; i + 1 < bytes.length; i += 2) {
+            swapped[i - 2] = bytes[i + 1];
+            swapped[i - 1] = bytes[i];
+        }
+        return swapped.toString('utf16le');
+    }
+    const utf8 = bytes.toString('utf8').replace(/^\uFEFF/, '');
+    if (utf8.includes('\u0000')) {
+        const utf16 = bytes.toString('utf16le').replace(/^\uFEFF/, '');
+        if (utf16.includes('{') || utf16.includes('[') || utf16.includes('CommandLine'))
+            return utf16;
+    }
+    return utf8;
+}
 /**
  * Cross-platform command existence check.
  */
@@ -178,7 +307,7 @@ export function commandExists(cmd) {
     let exists = false;
     try {
         if (isWindows) {
-            const r = spawnSync('where', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
+            const r = spawnSync('where.exe', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
             exists = r.status === 0;
         }
         else {
@@ -194,7 +323,7 @@ export function commandExists(cmd) {
 }
 /**
  * 解析命令的真实可执行文件绝对路径。
- * Windows: `where` 会列出全部同名文件（npm 全局 bin 同时生成无后缀 sh 包装、.cmd、.ps1），
+ * Windows: `where.exe` 会列出全部同名文件（npm 全局 bin 同时生成无后缀 sh 包装、.cmd、.ps1），
  *   其中无后缀的那个是 Unix sh 脚本，Windows 无法直接 spawn（ENOENT）。
  *   因此优先选 PATHEXT 可执行后缀（.cmd/.exe/.bat/.com），都没有才退回首行。
  * 失败返回 null。不缓存——刚安装的命令需要重新探测。
@@ -202,7 +331,7 @@ export function commandExists(cmd) {
 export function resolveCommandPath(cmd) {
     try {
         if (isWindows) {
-            const r = spawnSync('where', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
+            const r = spawnSync('where.exe', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
             if (r.status !== 0 || !r.stdout)
                 return null;
             const candidates = r.stdout.split(/\r?\n/).map(s => s.trim()).filter(Boolean);

package/dist/utils/ecweb-utils.js

@@ -1,8 +1,21 @@
 import fs from 'fs';
 import path from 'path';
-import { resolveGlobalPkg } from './npm-ops.js';
+import { compareVersions, resolveGlobalPkg } from './npm-ops.js';
 import { isWindows as platformIsWindows, resolveCommandPath } from './cross-platform.js';
-import { WEB_CLI_BIN, WEB_PACKAGE_NAME } from '../product.js';
+import { MIN_ECWEB_VERSION, WEB_CLI_BIN, WEB_PACKAGE_NAME } from '../product.js';
+/** EC Web owns the session-log reader, so older builds cannot safely serve a newer daemon. */
+export function isEcwebVersionSupported(version) {
+    const normalized = version?.trim();
+    if (!normalized || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(normalized))
+        return false;
+    return compareVersions(normalized, MIN_ECWEB_VERSION) >= 0;
+}
+export function ecwebVersionRequirementError(version) {
+    if (isEcwebVersionSupported(version))
+        return null;
+    const detected = version?.trim() || 'unknown';
+    return `EC Web ${detected} 低于最低要求 ${MIN_ECWEB_VERSION}，拒绝启动。请运行: npm install -g ${WEB_PACKAGE_NAME}@latest`;
+}
 function readEcwebPackageEntry(pkgJsonPath) {
     try {
         const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));

package/dist/utils/instance-registry.js

@@ -350,12 +350,20 @@ export function findOrphanProcesses() {
     // 1. 已登记 PID（自己 HOME 下的 main + 自己进程）
     const known = new Set([process.pid]);
     const status = scanInstances();
-    for (const m of status.mains)
-        known.add(m.record.pid);
-    for (const m of status.restartMonitors)
-        known.add(m.record.pid);
+    for (const m of status.mains) {
+        if (m.alive)
+            known.add(m.record.pid);
+    }
+    for (const m of status.restartMonitors) {
+        if (m.alive)
+            known.add(m.record.pid);
+    }
     // 2. 系统中所有跑 dist/index.js 的 node 进程
-    const candidates = findProcesses('node.*dist/index.js');
+    // Use a stable filename anchor for the Windows CIM query. The full path
+    // regex contains escaped separators and is applied after command lines have
+    // been fetched; embedding it in the CIM pre-filter can silently miss a
+    // backslash-delimited `dist\\index.js` command on some PowerShell builds.
+    const candidates = findProcesses('index\\.js');
     const orphans = [];
     for (const pid of candidates) {
         if (known.has(pid))
@@ -395,11 +403,21 @@ export function killOrphans(orphans) {
 }
 function readCmdline(pid) {
     if (isWindows) {
+        // WMIC is removed from recent Windows installations. Keep it as the
+        // first probe for older hosts, then use the supported CIM API when it is
+        // unavailable or returns no row.
         try {
             const result = spawnSync('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'CommandLine', '/value'], { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
             const out = result.stdout || '';
             const m = out.match(/CommandLine=([^\r\n]+)/);
-            return m ? m[1].trim() : '';
+            if (m?.[1]?.trim())
+                return m[1].trim();
+        }
+        catch { }
+        try {
+            const script = `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine`;
+            const result = spawnSync('powershell', ['-NoProfile', '-Command', script], { encoding: null, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+            return decodeWindowsOutput(result.stdout).trim();
         }
         catch {
             return '';
@@ -422,6 +440,25 @@ function readCmdline(pid) {
         }
     }
 }
+function decodeWindowsOutput(value) {
+    if (!value)
+        return '';
+    const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe)
+        return bytes.subarray(2).toString('utf16le');
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        const swapped = Buffer.allocUnsafe(bytes.length - 2);
+        for (let i = 2; i + 1 < bytes.length; i += 2) {
+            swapped[i - 2] = bytes[i + 1];
+            swapped[i - 1] = bytes[i];
+        }
+        return swapped.toString('utf16le');
+    }
+    const utf8 = bytes.toString('utf8').replace(/^\uFEFF/, '');
+    if (utf8.includes('\u0000'))
+        return bytes.toString('utf16le').replace(/^\uFEFF/, '');
+    return utf8;
+}
 function readProcessEnvironment(pid) {
     // Linux: /proc/<pid>/environ
     if (!isWindows && process.platform !== 'darwin') {

package/dist/utils/macos-autostart.js

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { getPackageRoot } from '../paths.js';
+export const MACOS_AUTOSTART_LABEL = 'cn.evolai.evolcore';
+function isMacos() {
+    return process.platform === 'darwin';
+}
+function plistPath() {
+    return path.join(os.homedir(), 'Library', 'LaunchAgents', `${MACOS_AUTOSTART_LABEL}.plist`);
+}
+function launchctl(args) {
+    return spawnSync('/bin/launchctl', args, {
+        encoding: 'utf8',
+        timeout: 15_000,
+    });
+}
+function commandError(result, fallback) {
+    return String(result.error?.message || result.stderr || result.stdout || fallback).trim();
+}
+function guiDomain() {
+    const uid = process.getuid?.();
+    return uid === undefined ? undefined : `gui/${uid}`;
+}
+function xmlLiteral(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function createPlist(runtimeRoot) {
+    const absoluteRoot = path.resolve(runtimeRoot);
+    const cliEntry = path.join(getPackageRoot(), 'dist', 'cli', 'index.js');
+    if (!fs.existsSync(cliEntry)) {
+        throw new Error(`找不到 EvolCore CLI 入口: ${cliEntry}`);
+    }
+    const environment = [
+        ['EVOLCORE_HOME', absoluteRoot],
+        ['HOME', os.homedir()],
+        ['PATH', Array.from(new Set([
+                path.dirname(process.execPath),
+                ...(process.env.PATH ?? '').split(path.delimiter).filter(Boolean),
+            ])).join(path.delimiter)],
+    ];
+    const environmentXml = environment
+        .map(([key, value]) => `    <key>${xmlLiteral(key)}</key>\n    <string>${xmlLiteral(value)}</string>`)
+        .join('\n');
+    const args = [process.execPath, '--no-warnings=ExperimentalWarning', cliEntry, 'start']
+        .map(value => `    <string>${xmlLiteral(value)}</string>`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlLiteral(MACOS_AUTOSTART_LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${environmentXml}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xmlLiteral(path.join(absoluteRoot, 'logs', 'autostart.stdout.log'))}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlLiteral(path.join(absoluteRoot, 'logs', 'autostart.stderr.log'))}</string>
+</dict>
+</plist>
+`;
+}
+function restorePlist(file, previous) {
+    try {
+        if (previous === undefined)
+            fs.rmSync(file, { force: true });
+        else
+            fs.writeFileSync(file, previous, { encoding: 'utf8', mode: 0o600 });
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+export function macosAutostartInstalled() {
+    if (!isMacos())
+        return false;
+    const domain = guiDomain();
+    if (!domain)
+        return false;
+    const result = launchctl(['print', `${domain}/${MACOS_AUTOSTART_LABEL}`]);
+    return result.status === 0;
+}
+export function configureMacosAutostart(enabled, runtimeRoot) {
+    if (!isMacos()) {
+        return {
+            ok: !enabled,
+            enabled: false,
+            ...(!enabled ? {} : { error: 'macOS 登录自启仅支持 macOS 主机' }),
+        };
+    }
+    const domain = guiDomain();
+    if (!domain) {
+        return { ok: false, enabled: false, error: '无法确定当前 macOS 用户 UID' };
+    }
+    const file = plistPath();
+    if (!enabled) {
+        const result = launchctl(['bootout', `${domain}/${MACOS_AUTOSTART_LABEL}`]);
+        if (result.status !== 0 && macosAutostartInstalled()) {
+            return {
+                ok: false,
+                enabled: true,
+                error: commandError(result, '删除 macOS 登录自启失败'),
+            };
+        }
+        try {
+            fs.rmSync(file, { force: true });
+        }
+        catch (error) {
+            // Keep the previous state coherent: a LaunchAgents plist that cannot be
+            // removed would otherwise silently re-enable the job at the next login.
+            const restored = launchctl(['bootstrap', domain, file]);
+            return {
+                ok: false,
+                enabled: restored.status === 0 || macosAutostartInstalled(),
+                error: `删除 macOS 登录自启配置失败: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        return { ok: true, enabled: false };
+    }
+    let previousPlist;
+    let previouslyInstalled = false;
+    try {
+        const absoluteRoot = path.resolve(runtimeRoot);
+        if (fs.existsSync(file)) {
+            previousPlist = fs.readFileSync(file, 'utf8');
+            previouslyInstalled = macosAutostartInstalled();
+        }
+        fs.mkdirSync(path.join(absoluteRoot, 'logs'), { recursive: true });
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, createPlist(absoluteRoot), { encoding: 'utf8', mode: 0o600 });
+        // Re-bootstrap so repeated `ec init --auto-start` updates the command and paths.
+        launchctl(['bootout', `${domain}/${MACOS_AUTOSTART_LABEL}`]);
+        const result = launchctl(['bootstrap', domain, file]);
+        if (result.status !== 0) {
+            const restoreError = restorePlist(file, previousPlist);
+            let restored = false;
+            if (!restoreError && previouslyInstalled && previousPlist !== undefined) {
+                const restoreResult = launchctl(['bootstrap', domain, file]);
+                restored = restoreResult.status === 0 || macosAutostartInstalled();
+            }
+            else if (!previouslyInstalled) {
+                // A failed bootstrap may still have partially loaded the job.
+                launchctl(['bootout', `${domain}/${MACOS_AUTOSTART_LABEL}`]);
+            }
+            const rollbackSuffix = restoreError ? `; 恢复原配置失败: ${restoreError}` : '';
+            return {
+                ok: false,
+                enabled: restored,
+                error: `${commandError(result, '创建 macOS 登录自启失败')}${rollbackSuffix}`,
+            };
+        }
+        return { ok: true, enabled: true };
+    }
+    catch (error) {
+        const restoreError = restorePlist(file, previousPlist);
+        const rollbackSuffix = restoreError ? `; 恢复原配置失败: ${restoreError}` : '';
+        return {
+            ok: false,
+            enabled: previouslyInstalled,
+            error: `${error instanceof Error ? error.message : String(error)}${rollbackSuffix}`,
+        };
+    }
+}

package/dist/utils/process-introspect.js

@@ -115,12 +115,12 @@ function winPowerShellCreationDate(pid) {
     const result = spawnSync('powershell', [
         '-NoProfile',
         '-Command',
-        `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CreationDate`,
+        `(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CreationDate.ToUniversalTime().ToString('o')`,
     ], { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
     const out = result.stdout?.trim();
     if (!out)
         return null;
-    return parseCimDate(out);
+    return parseCimDate(out) ?? parseDateString(out);
 }
 function winWmicCreationDate(pid) {
     const result = spawnSync('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'CreationDate', '/value'], { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
@@ -128,7 +128,11 @@ function winWmicCreationDate(pid) {
     const m = out.match(/CreationDate=([^\r\n]+)/);
     if (!m)
         return null;
-    return parseCimDate(m[1].trim());
+    return parseCimDate(m[1].trim()) ?? parseDateString(m[1].trim());
+}
+function parseDateString(value) {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
 }
 /**
  * 解析 CIM/WMI 日期格式：yyyyMMddHHmmss.ffffff±TZZZ