evolcore 0.0.35 → 0.0.36

package/dist/utils/aid-bind.js

@@ -1,308 +1,28 @@
-import crypto from 'crypto';
-import { loadAgent, loadDaemonConfig, saveAgent, saveDaemonConfig } from '../config-store.js';
-import { resolveEffective } from '../config/config-manager.js';
-import { readInstalledEvolcoreVersion as readEvolcoreVersion } from './evolcore-version.js';
+import { randomUUID } from 'crypto';
+const BIND_TTL_MS = 10 * 60 * 1000;
+const deferredMessage = 'Evol App ownership binding is deferred; use ec aid bind <ownerAid> [--subject <subjectAid>]';
 export class BindService {
-    opts;
-    tasks = new Map();
-    taskIdsByTokenHash = new Map();
-    cleanupTimer = null;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    startCleanup() {
-        if (this.cleanupTimer)
-            return;
-        this.cleanupTimer = setInterval(() => this.cleanup(), 60_000);
-        this.cleanupTimer.unref?.();
-    }
-    stopCleanup() {
-        if (!this.cleanupTimer)
-            return;
-        clearInterval(this.cleanupTimer);
-        this.cleanupTimer = null;
-    }
-    begin(req) {
-        if (req.bindType !== 'daemon' && req.bindType !== 'agent') {
-            return { ok: false, code: 'INVALID_BIND_TYPE', error: 'invalid bindType' };
-        }
-        const targetAid = req.bindType === 'daemon' ? (req.targetAid ?? this.opts.receiverAid) : req.targetAid;
-        if (!targetAid || typeof targetAid !== 'string') {
-            return { ok: false, code: 'MISSING_TARGET', error: 'missing targetAid' };
-        }
-        if (req.bindType === 'daemon' && targetAid !== this.opts.receiverAid) {
-            return { ok: false, code: 'TARGET_MISMATCH', error: 'daemon targetAid must equal control AID' };
-        }
-        if (req.bindType === 'agent' && !loadAgent(targetAid)) {
-            return { ok: false, code: 'TARGET_NOT_FOUND', error: `agent not found: ${targetAid}` };
-        }
-        const taskId = crypto.randomUUID();
-        let token = generatePublicToken();
-        let tokenHash = hashToken(token);
-        while (this.taskIdsByTokenHash.has(tokenHash)) {
-            token = generatePublicToken();
-            tokenHash = hashToken(token);
-        }
-        const ttlMs = clampTtl(req.ttlMs);
-        const expiresAt = Date.now() + ttlMs;
-        const task = {
-            taskId,
-            bindType: req.bindType,
-            receiverAid: this.opts.receiverAid,
-            targetAid,
-            agentName: req.agentName,
-            tokenHash,
-            createdAt: Date.now(),
-            expiresAt,
-            status: 'pending',
-        };
-        this.tasks.set(taskId, task);
-        this.taskIdsByTokenHash.set(tokenHash, taskId);
-        this.cleanup();
+    constructor(_options) { }
+    startCleanup() { }
+    stopCleanup() { }
+    begin(_request) {
         return {
             ok: true,
-            taskId,
-            expiresAt,
-            qrData: {
-                type: 'evolcore.bind',
-                version: readEvolcoreVersion(),
-                bindType: req.bindType,
-                daemonAid: this.opts.receiverAid,
-                ...(req.bindType === 'daemon' ? { platform: getPlatform() } : {}),
-                ...(req.bindType === 'agent' ? { agentAid: targetAid, agentName: req.agentName ?? null } : {}),
-                token,
-                expiresAt,
-            },
+            taskId: randomUUID(),
+            qrData: {},
+            expiresAt: Date.now() + BIND_TTL_MS,
         };
     }
-    status(taskId) {
-        if (!taskId)
-            return { ok: false, code: 'MISSING_TASK', error: 'missing taskId' };
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return { ok: false, code: 'TASK_NOT_FOUND', error: 'binding task not found' };
-        if (task.status === 'pending' && Date.now() > task.expiresAt) {
-            task.status = 'expired';
-            task.finishedAt ??= task.expiresAt;
-        }
-        return {
-            ok: true,
-            taskId: task.taskId,
-            status: task.status,
-            boundAid: task.boundAid,
-            boundName: task.boundName,
-        };
+    status(_taskId) {
+        return { ok: false, code: 'OWNERSHIP_APP_DEFERRED', error: deferredMessage };
     }
-    cancel(taskId) {
-        if (!taskId)
-            return { ok: false, code: 'MISSING_TASK', error: 'missing taskId' };
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return { ok: false, code: 'TASK_NOT_FOUND', error: 'binding task not found' };
-        if (task.status === 'pending') {
-            task.status = 'cancelled';
-            task.finishedAt = Date.now();
-        }
-        return {
-            ok: true,
-            taskId: task.taskId,
-            status: task.status,
-            boundAid: task.boundAid,
-            boundName: task.boundName,
-        };
+    cancel(_taskId) {
+        return { ok: false, code: 'OWNERSHIP_APP_DEFERRED', error: deferredMessage };
     }
-    async handleRequest(payload, fromAid) {
+    async handleRequest(payload, _fromAid) {
         if (payload?.type !== 'bind.request')
             return null;
-        const bindType = payload.bindType === 'agent' ? 'agent' : 'daemon';
-        const fail = (code, message) => ({
-            type: 'bind.response',
-            bindType,
-            success: false,
-            error: { code, message },
-        });
-        if (!payload.token)
-            return fail('INVALID_TOKEN', 'invalid token');
-        const taskId = this.taskIdsByTokenHash.get(hashToken(payload.token));
-        if (!taskId)
-            return fail('TASK_NOT_FOUND', 'binding task not found');
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return fail('TASK_NOT_FOUND', 'binding task not found');
-        if (payload.bindType !== task.bindType)
-            return fail('BIND_TYPE_MISMATCH', 'bindType mismatch');
-        if (!fromAid)
-            return fail('INTERNAL_ERROR', 'missing AUN sender');
-        if (task.status === 'pending' && Date.now() > task.expiresAt) {
-            task.status = 'expired';
-            task.finishedAt ??= task.expiresAt;
-            return fail('TASK_EXPIRED', 'binding task expired');
-        }
-        if (task.status === 'bound') {
-            // The owner write and task transition necessarily happen before the caller
-            // can send bind.response. If that send fails, the App retries the same
-            // authenticated request. Replay the original success only to the AID that
-            // completed the bind; other senders must not receive daemonInfo.
-            if (task.boundAid === fromAid && task.boundResponse)
-                return task.boundResponse;
-            return fail('ALREADY_BOUND', 'binding task already completed');
-        }
-        if (task.status !== 'pending')
-            return fail('TASK_NOT_FOUND', 'binding task is not pending');
-        if (!timingSafeTokenEqual(payload.token, task.tokenHash)) {
-            return fail('INVALID_TOKEN', 'invalid token');
-        }
-        try {
-            // Build and retain the exact response before committing the bind so a
-            // post-commit transport failure can be recovered by an idempotent retry.
-            const response = this.buildSuccessResponse(task);
-            this.applyOwnerBinding(task, fromAid);
-            task.status = 'bound';
-            task.boundAid = fromAid;
-            task.boundName = payload.clientName;
-            task.boundResponse = response;
-            task.finishedAt = Date.now();
-            return response;
-        }
-        catch (e) {
-            return fail('INTERNAL_ERROR', e?.message || String(e));
-        }
-    }
-    buildSuccessResponse(task) {
-        const details = task.bindType === 'agent' ? this.buildAgentBindDetails(task) : null;
-        return {
-            type: 'bind.response',
-            bindType: task.bindType,
-            success: true,
-            daemonInfo: {
-                daemonAid: task.receiverAid,
-                ...(task.bindType === 'agent' ? { agentAid: task.targetAid } : {}),
-                bindType: task.bindType,
-                ...(task.bindType === 'daemon'
-                    ? {
-                        version: readEvolcoreVersion(),
-                        platform: getPlatform(),
-                        uptime: this.opts.getUptimeSeconds(),
-                        baseagents: this.opts.getAvailableBaseagents(),
-                    }
-                    : {
-                        active_baseagent: details.baseagent.active_baseagent,
-                        model: details.baseagent.model,
-                        effort: details.baseagent.effort,
-                        channels: details.channels,
-                        agentName: task.agentName,
-                    }),
-            },
-        };
-    }
-    buildAgentBindDetails(task) {
-        const agent = loadAgent(task.targetAid);
-        const config = resolveEffective({ self: task.targetAid }, { expand: true });
-        return {
-            baseagent: resolveBaseagentInfo(config),
-            channels: summarizeChannels(agent?.channels ?? []),
-        };
-    }
-    applyOwnerBinding(task, ownerAid) {
-        if (task.bindType === 'daemon') {
-            const cfg = loadDaemonConfig();
-            const current = cfg.owners ?? [];
-            const owners = [ownerAid, ...current.filter(o => o !== ownerAid)];
-            saveDaemonConfig({ ...cfg, $schema_version: cfg.$schema_version ?? 1, owners });
-            this.opts.onDaemonOwnersUpdated?.(owners);
-            return;
-        }
-        const agent = loadAgent(task.targetAid);
-        if (!agent)
-            throw new Error(`agent not found: ${task.targetAid}`);
-        const current = agent.owners ?? [];
-        const owners = [ownerAid, ...current.filter(o => o !== ownerAid)];
-        saveAgent({ ...agent, owners });
-        this.opts.onAgentOwnerUpdated?.(task.targetAid, ownerAid);
-    }
-    cleanup() {
-        const now = Date.now();
-        for (const [id, task] of this.tasks) {
-            if (task.status === 'pending' && now > task.expiresAt) {
-                task.status = 'expired';
-                task.finishedAt ??= task.expiresAt;
-            }
-            if (task.status === 'cancelled') {
-                this.deleteTask(id);
-            }
-            else if (task.status === 'expired' && now - (task.finishedAt ?? task.expiresAt) > 10 * 60_000) {
-                this.deleteTask(id);
-            }
-            else if (task.status === 'bound' && task.finishedAt && now - task.finishedAt > 10 * 60_000) {
-                this.deleteTask(id);
-            }
-        }
-        if (this.tasks.size <= 128)
-            return;
-        const sorted = [...this.tasks.values()].sort((a, b) => a.createdAt - b.createdAt);
-        for (const task of sorted) {
-            if (this.tasks.size <= 128)
-                break;
-            if (task.status !== 'pending')
-                this.deleteTask(task.taskId);
-        }
-    }
-    deleteTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return;
-        this.tasks.delete(taskId);
-        this.taskIdsByTokenHash.delete(task.tokenHash);
-    }
-}
-function clampTtl(ttlMs) {
-    if (!ttlMs || !Number.isFinite(ttlMs))
-        return 10 * 60_000;
-    return Math.max(60_000, Math.min(ttlMs, 10 * 60_000));
-}
-function hashToken(token) {
-    return crypto.createHash('sha256').update(token, 'utf8').digest('hex');
-}
-function generatePublicToken() {
-    return crypto.randomBytes(16).toString('base64url'); // 128 bits for stronger security
-}
-function timingSafeTokenEqual(token, expectedHash) {
-    const actual = Buffer.from(hashToken(token), 'hex');
-    const expected = Buffer.from(expectedHash, 'hex');
-    if (actual.length !== expected.length)
-        return false;
-    return crypto.timingSafeEqual(actual, expected);
-}
-function resolveBaseagentInfo(config) {
-    const baseagents = (config?.baseagents ?? {});
-    const active_baseagent = ('active_baseagent' in (config ?? {}) && typeof config?.active_baseagent === 'string')
-        ? config.active_baseagent
-        : pickFirstBaseagent(baseagents);
-    const block = active_baseagent ? baseagents[active_baseagent] : undefined;
-    const model = typeof block?.model === 'string' ? block.model : undefined;
-    const effort = typeof block?.effort === 'string'
-        ? block.effort
-        : (typeof block?.reasoning === 'string' ? block.reasoning : undefined);
-    return { active_baseagent, model, effort };
-}
-function pickFirstBaseagent(baseagents) {
-    for (const name of ['claude', 'codex', 'gemini', 'ecagent']) {
-        if (baseagents[name] !== undefined)
-            return name;
+        return { type: 'bind.response', bindType: payload.bindType === 'agent' ? 'agent' : 'daemon', success: false,
+            error: { code: 'OWNERSHIP_APP_DEFERRED', message: deferredMessage } };
     }
-    return 'claude';
-}
-function summarizeChannels(channels) {
-    return channels.map(ch => ({
-        type: ch.type,
-        name: ch.name,
-        enabled: ch.enabled !== false,
-    }));
-}
-function getPlatform() {
-    if (process.platform === 'win32')
-        return 'windows';
-    if (process.platform === 'darwin')
-        return 'macos';
-    return 'linux';
 }

package/dist/utils/avatar-upload.js

@@ -16,6 +16,7 @@ const MAX_AVATAR_RATIO = 1.25;
 const MAX_AVATAR_REDIRECTS = 3;
 const AVATAR_DOWNLOAD_TIMEOUT_MS = 10_000;
 const AVATAR_DNS_TIMEOUT_MS = 2_000;
+const ALLOWED_AUN_STORAGE_PORTS = new Set(['9470', '9471', '39470']);
 const ALLOWED_AVATAR_MIMES = new Set(['image/png', 'image/jpeg', 'image/webp']);
 const MIME_EXT = {
     'image/png': 'png',
@@ -210,7 +211,7 @@ function isPrivateAddress(address) {
     }
     return false;
 }
-async function validateAvatarUrl(url) {
+async function validateAvatarUrl(url, aunStorageHost) {
     let parsed;
     try {
         parsed = new URL(url);
@@ -224,8 +225,12 @@ async function validateAvatarUrl(url) {
         return { ok: false, reason: '头像 URL 缺少主机名' };
     if (parsed.username || parsed.password)
         return { ok: false, reason: '头像 URL 不允许携带认证信息' };
-    if (parsed.port && parsed.port !== '443')
-        return { ok: false, reason: '头像 URL 仅支持 HTTPS 默认端口' };
+    if (parsed.port && parsed.port !== '443') {
+        const isAunStorageRedirect = parsed.hostname === aunStorageHost
+            && ALLOWED_AUN_STORAGE_PORTS.has(parsed.port);
+        if (!isAunStorageRedirect)
+            return { ok: false, reason: '头像 URL 仅支持 HTTPS 默认端口' };
+    }
     const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
     if (isPrivateAddress(hostname))
         return { ok: false, reason: '头像 URL 指向受限地址' };
@@ -250,10 +255,17 @@ async function validateAvatarUrl(url) {
 }
 async function downloadAvatarBuffer(sourceUrl) {
     let current = sourceUrl;
+    let aunStorageHost;
     for (let redirect = 0; redirect <= MAX_AVATAR_REDIRECTS; redirect++) {
-        const checked = await validateAvatarUrl(current);
+        const checked = await validateAvatarUrl(current, aunStorageHost);
         if (!checked.ok)
             return fail(checked.reason, 'INVALID_ARGS');
+        if (redirect === 0) {
+            // Canonical AID URLs redirect to their domain's Storage service on a public service port.
+            const aidDomain = checked.url.hostname.split('.').slice(1);
+            if (aidDomain.length >= 2)
+                aunStorageHost = `storage.${aidDomain.join('.')}`;
+        }
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), AVATAR_DOWNLOAD_TIMEOUT_MS);
         let response;

package/dist/utils/cross-platform.js

@@ -286,55 +286,120 @@ export function spawnDetachedNode(args, env = {}) {
  * In a checkout the monitor is executed through tsx, where a syntax error
  * anywhere in its import graph is fatal at load time — and the usual
  * `stdio: 'ignore'` would throw that diagnostic away. So stderr is captured,
- * and success requires the child to still be alive after it had a chance to
- * fail, not merely to have been spawned.
+ * and success requires the child to register as a monitor, not merely to have
+ * been spawned. A live but unregistered child at timeout is reported as
+ * pending, since it may still take ownership after the caller returns.
  *
  * `isAliveInRegistry` lets the caller define proof-of-life without dragging the
  * instance registry into this module.
  */
-export async function launchMonitorAndConfirm(args, env, isAliveInRegistry, hasOtherLiveMonitor, timeoutMs = 15_000) {
-    const child = spawn(process.execPath, [...args], {
-        detached: true,
-        stdio: ['ignore', 'ignore', 'pipe'],
-        windowsHide: isWindows,
-        env: { ...process.env, ...env },
-    });
+export async function launchMonitorAndConfirm(args, env, isAliveInRegistry, hasOtherLiveMonitor, options = {}) {
+    const startedAt = Date.now();
+    const diagnostic = (message) => {
+        if (!options.logFilePath)
+            return;
+        try {
+            fs.appendFileSync(options.logFilePath, `[${new Date().toISOString()}] [requestId=${options.requestId ?? 'unknown'}] ${message}\n`);
+        }
+        catch { }
+    };
+    let logFd;
+    let child;
+    try {
+        if (options.logFilePath) {
+            fs.mkdirSync(path.dirname(options.logFilePath), { recursive: true });
+            logFd = fs.openSync(options.logFilePath, 'a');
+        }
+        child = spawn(process.execPath, [...args], {
+            detached: true,
+            stdio: logFd === undefined ? ['ignore', 'pipe', 'pipe'] : ['ignore', logFd, logFd],
+            windowsHide: isWindows,
+            env: { ...process.env, ...env },
+        });
+    }
+    catch (error) {
+        diagnostic(`Launch failed: ${error.message}`);
+        return { ok: false, reason: error.message };
+    }
+    finally {
+        if (logFd !== undefined)
+            fs.closeSync(logFd);
+    }
     let stderrTail = '';
-    child.stderr?.on('data', (chunk) => {
-        stderrTail = (stderrTail + chunk.toString()).slice(-2000);
-    });
+    const finish = (result) => {
+        diagnostic(`Launch result: pid=${child.pid ?? 'unknown'} ok=${result.ok} pending=${result.pending ?? false} elapsedMs=${Date.now() - startedAt} reason=${result.reason ?? 'accepted'}`);
+        if (!result.ok && options.logFilePath) {
+            let tailFd;
+            try {
+                tailFd = fs.openSync(options.logFilePath, 'r');
+                const size = fs.fstatSync(tailFd).size;
+                const buffer = Buffer.alloc(Math.min(size, 2000));
+                fs.readSync(tailFd, buffer, 0, buffer.length, Math.max(0, size - buffer.length));
+                stderrTail = buffer.toString('utf8');
+            }
+            catch { }
+            finally {
+                if (tailFd !== undefined)
+                    fs.closeSync(tailFd);
+            }
+        }
+        return { ...result, ...(!result.ok ? { stderrTail } : {}) };
+    };
+    child.stdout?.on('data', () => { });
+    child.stderr?.on('data', (chunk) => { stderrTail = (stderrTail + chunk.toString()).slice(-2000); });
     // Capturing stderr must not defeat detached-process semantics. A referenced
     // pipe keeps the caller's event loop alive until the monitor exits, which
     // makes restart commands wait for the monitor's full lifetime.
+    child.stdout?.unref?.();
     child.stderr?.unref?.();
     let exitCode = null;
+    let exited = false;
+    let exitSignal = null;
     let spawnError = null;
-    child.on('exit', code => { exitCode = code; });
-    child.on('error', err => { spawnError = err.message; });
+    child.on('exit', (code, signal) => {
+        exited = true;
+        exitCode = code;
+        exitSignal = signal;
+        diagnostic(`Child exited: pid=${child.pid ?? 'unknown'} exit=${code} signal=${signal ?? 'none'} elapsedMs=${Date.now() - startedAt}`);
+    });
+    child.on('error', err => {
+        spawnError = err.message;
+        diagnostic(`Child error: ${err.message}`);
+    });
     const childPid = child.pid;
     child.unref();
+    diagnostic(`Child spawned: pid=${childPid ?? 'unknown'}`);
     if (!childPid)
-        return { ok: false, reason: 'spawn 未返回 PID' };
-    const deadline = Date.now() + timeoutMs;
+        return finish({ ok: false, reason: 'spawn 未返回 PID' });
+    try {
+        options.onSpawn?.(childPid);
+    }
+    catch (error) {
+        diagnostic(`Spawn callback failed: ${error.message}`);
+    }
+    const accepted = () => isAliveInRegistry(childPid) || hasOtherLiveMonitor(childPid);
+    const deadline = Date.now() + (options.timeoutMs ?? 15_000);
     while (Date.now() < deadline) {
         await new Promise(resolve => setTimeout(resolve, 300));
+        if (accepted())
+            return finish({ ok: true, pid: childPid });
         if (spawnError)
-            return { ok: false, reason: spawnError, stderrTail };
-        if (exitCode !== null) {
-            // Exiting cleanly is legitimate when another monitor already owns this
-            // restart (single-instance election) — that one is alive and in charge.
-            if (exitCode === 0 && hasOtherLiveMonitor(childPid))
-                return { ok: true };
-            return { ok: false, reason: `进程已退出，exit=${exitCode}`, stderrTail };
+            return finish({ ok: false, pid: childPid, reason: spawnError });
+        if (exited && !options.isPendingInRegistry?.()) {
+            return finish({ ok: false, pid: childPid, reason: `进程已退出，exit=${exitCode}, signal=${exitSignal ?? 'none'}` });
         }
-        // Registering means the module graph loaded and the monitor started work.
-        if (isAliveInRegistry(childPid))
-            return { ok: true };
     }
-    // Still running but not yet registered: a slow start is not a failure.
-    if (isProcessRunning(childPid))
-        return { ok: true };
-    return { ok: false, reason: '进程未登记且已消失', stderrTail };
+    if (accepted())
+        return finish({ ok: true, pid: childPid });
+    if ((!exited && isProcessRunning(childPid)) || options.isPendingInRegistry?.()) {
+        return finish({
+            ok: false,
+            pid: childPid,
+            pending: true,
+            reason: '进程仍在运行但尚未登记为 restart-monitor',
+        });
+    }
+    return finish({ ok: false, pid: childPid, reason: '进程未登记且已消失' });
 }
 /**
  * Copy the monitor out of the package directory so an upgrade cannot replace it
@@ -867,10 +932,10 @@ export function commandExists(cmd) {
  *   因此优先选 PATHEXT 可执行后缀（.cmd/.exe/.bat/.com），都没有才退回首行。
  * 失败返回 null。不缓存——刚安装的命令需要重新探测。
  */
-export function resolveCommandPath(cmd) {
+export function resolveCommandPath(cmd, env = process.env) {
     try {
         if (isWindows) {
-            const r = spawnSync('where.exe', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true });
+            const r = spawnSync('where.exe', [cmd], { encoding: 'utf-8', stdio: 'pipe', windowsHide: true, env });
             if (r.status !== 0 || !r.stdout)
                 return null;
             const candidates = r.stdout.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
@@ -881,8 +946,18 @@ export function resolveCommandPath(cmd) {
             return runnable || candidates[0];
         }
         else {
-            const out = execFileSync('which', [cmd], { encoding: 'utf-8', stdio: 'pipe' }).trim();
-            return out || null;
+            const candidates = cmd.includes(path.sep)
+                ? [path.resolve(cmd)]
+                : (env.PATH ?? '').split(path.delimiter).map(directory => path.resolve(directory || '.', cmd));
+            for (const candidate of candidates) {
+                try {
+                    fs.accessSync(candidate, fs.constants.X_OK);
+                    if (fs.statSync(candidate).isFile())
+                        return candidate;
+                }
+                catch { }
+            }
+            return null;
         }
     }
     catch {

package/dist/utils/ecweb-supervisor.js

@@ -196,7 +196,7 @@ export function createEcwebSupervisor(options) {
             catch { }
         }
         if (!launch) {
-            options.logger.warn(`ECWeb 启动入口不存在，请安装 ${WEB_PACKAGE_NAME}@latest`);
+            options.logger.warn('ECWeb 启动入口不存在，请重新安装包含匹配 ECWeb 的 EvolCore 版本。');
             return;
         }
         const versionError = ecwebVersionRequirementError(version);

package/dist/utils/ecweb-utils.js

@@ -5,6 +5,13 @@ import { isWindows as platformIsWindows, resolveCommandPath } from './cross-plat
 import { MIN_ECWEB_VERSION, WEB_CLI_BIN, WEB_PACKAGE_NAME } from '../product.js';
 import { resolvePaths } from '../paths.js';
 import { ipcQuery } from '../ipc.js';
+import { ecwebService } from '../config/daemon-services.js';
+export function resolveEcwebExternalUrl(config) {
+    const aid = config.aid?.trim();
+    if (!aid || ecwebService(config.services)?.enabled !== true)
+        return null;
+    return `https://${aid}/proxy/ecweb`;
+}
 /** EC Web owns the session-log reader, so older builds cannot safely serve a newer daemon. */
 export function isEcwebVersionSupported(version) {
     const normalized = version?.trim();
@@ -16,7 +23,7 @@ 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`;
+    return `EC Web ${detected} 低于最低要求 ${MIN_ECWEB_VERSION}，拒绝启动。请升级 EvolCore 到包含匹配 EC Web 的版本。`;
 }
 function readEcwebPackageEntry(pkgJsonPath) {
     try {