evolcore 0.0.10 → 0.0.12

package/dist/agents/ecagent-runner.js

@@ -9,7 +9,9 @@ import { requestDangerousCommandPermission } from '../core/permission/approval-g
 import { normalizePermissionMode } from '../core/permission/mode.js';
 import { checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
 import { logger } from '../utils/logger.js';
+import { summarizeToolInputForAudit } from '../utils/tool-summary.js';
 import { resolveEcagentConfig } from './baseagent.js';
+import { buildModelRequestHeaders } from './request-identity.js';
 const PROVIDER_ID = 'evolcore-gateway';
 const DEFAULT_SYSTEM_PROMPT = `You are ecagent, the coding agent built into EvolCore.
 Work directly in the current project. Inspect relevant files before changing them, keep edits scoped, and verify the result.
@@ -252,6 +254,7 @@ function createOpenAiTransport(config) {
                             authorization: `Bearer ${config.apiKey}`,
                             'content-type': 'application/json',
                             ...Object.fromEntries(Object.entries(options?.headers ?? {}).filter((entry) => entry[1] !== null)),
+                            ...config.headers,
                         },
                         body: JSON.stringify(payload),
                         signal: controller.signal,
@@ -678,7 +681,15 @@ export class EcagentRunner {
     onCompactStart;
     modelCache;
     constructor(config, callbacks) {
-        this.config = config;
+        this.config = {
+            ...config,
+            headers: buildModelRequestHeaders({
+                baseagent: 'ecagent',
+                baseUrl: config.baseUrl,
+                agentAid: config.evolcoreAgentAid,
+                configuredHeaders: config.headers,
+            }),
+        };
         this.model = config.model;
         this.effort = config.effort;
         this.onSessionIdUpdate = callbacks?.onSessionIdUpdate;
@@ -714,7 +725,11 @@ export class EcagentRunner {
         try {
             const signal = AbortSignal.timeout(MODEL_LIST_TIMEOUT_MS);
             const response = await fetch(`${this.config.baseUrl.replace(/\/+$/, '')}/models`, {
-                headers: { authorization: `Bearer ${this.config.apiKey}` }, signal,
+                headers: {
+                    authorization: `Bearer ${this.config.apiKey}`,
+                    ...this.config.headers,
+                },
+                signal,
             });
             if (!response.ok)
                 throw new Error(`Failed to list ecagent models: HTTP ${response.status}`);
@@ -943,19 +958,43 @@ export class EcagentRunner {
     }
     async authorizeTool(sessionId, projectPath, mode, toolName, input) {
         const permissionContext = this.permissionContexts.get(sessionId);
+        const recordBlockedOperation = async (policyCode, operationInput = input) => {
+            try {
+                await permissionContext?.recordExecutionAnomaly?.({
+                    code: 'operation_blocked',
+                    severity: 'warning',
+                    phase: 'execution',
+                    occurredAt: Date.now(),
+                    toolName,
+                    policyCode,
+                    summary: summarizeToolInputForAudit(toolName, operationInput).slice(0, 512),
+                    effect: 'operation_skipped',
+                });
+            }
+            catch (error) {
+                logger.warn(`[EcagentRunner] failed to record blocked operation: session=${sessionId} tool=${toolName} code=${policyCode} error=${error instanceof Error ? error.message : String(error)}`);
+            }
+        };
         const policy = permissionContext?.policyHook?.(toolName, input);
-        if (policy?.block)
+        if (policy?.block) {
+            await recordBlockedOperation(policy.policyCode ?? 'session_policy_hook');
             return { block: true, reason: policy.reason || '当前会话策略拒绝此工具调用' };
+        }
         const preflight = evaluateToolPreflight(toolName, input, {
             sessionId,
+            selfAid: permissionContext?.selfAid,
             channel: permissionContext?.channel,
             userId: permissionContext?.userId,
             role: permissionContext?.role,
             permissionMode: mode,
             projectPath,
         });
-        if (preflight.behavior === 'deny')
+        if (preflight.behavior === 'deny') {
+            if (preflight.policyCode) {
+                await recordBlockedOperation(preflight.policyCode, input);
+            }
             return { block: true, reason: preflight.message };
+        }
         if (preflight.behavior === 'allow')
             return {};
         const checkedInput = preflight.input;
@@ -963,11 +1002,19 @@ export class EcagentRunner {
             const decision = checkReadonly(toolName, checkedInput, projectPath, {
                 sessionId, channel: permissionContext?.channel, peerId: permissionContext?.userId, role: permissionContext?.role,
             });
-            return decision.behavior === 'deny' ? { block: true, reason: decision.message } : {};
+            if (decision.behavior === 'deny') {
+                await recordBlockedOperation('readonly_mode', checkedInput);
+                return { block: true, reason: decision.message };
+            }
+            return {};
         }
         const dangerous = checkDangerousCommand(toolName, checkedInput);
         if (mode === 'auto') {
-            return dangerous.isDangerous ? { block: true, reason: `危险操作已由 auto 模式拒绝：${dangerous.reason}` } : {};
+            if (dangerous.isDangerous) {
+                await recordBlockedOperation('auto_dangerous_command', checkedInput);
+                return { block: true, reason: `危险操作已由 auto 模式拒绝：${dangerous.reason}` };
+            }
+            return {};
         }
         const prompt = permissionContext?.sendPrompt ?? this.sendPromptFn;
         const decision = await requestDangerousCommandPermission(this.permissionGateway, sessionId, toolName, checkedInput, prompt, permissionContext, `ecagent:${mode}`, mode);

package/dist/agents/gemini-runner.js

@@ -344,6 +344,7 @@ export class GeminiRunner {
             cwd: projectPath,
             stdio: ['pipe', 'pipe', 'pipe'],
             env,
+            windowsHide: process.platform === 'win32',
         });
         this.activeProcesses.set(sessionId, child);
         // Log stderr

package/dist/agents/request-identity.js

@@ -0,0 +1,55 @@
+import { logger } from '../utils/logger.js';
+import { readInstalledEvolcoreVersion } from '../utils/evolcore-version.js';
+export const EVOLCORE_REQUEST_HEADERS = {
+    version: 'X-EvolCore-Version',
+    agentAid: 'X-EvolCore-Agent-AID',
+    baseagent: 'X-EvolCore-Base-Agent',
+};
+const RESERVED_HEADER_NAMES = new Set(Object.values(EVOLCORE_REQUEST_HEADERS).map(name => name.toLowerCase()));
+const warnedReservedHeaders = new Set();
+function officialHostname(baseagent) {
+    return baseagent === 'claude' ? 'api.anthropic.com' : 'api.openai.com';
+}
+export function isOfficialModelEndpoint(baseagent, baseUrl) {
+    const configured = baseUrl?.trim();
+    if (!configured)
+        return true;
+    try {
+        return new URL(configured).hostname.toLowerCase() === officialHostname(baseagent);
+    }
+    catch {
+        // Invalid URLs fail at the request layer. Treat them as configured here so
+        // identity behavior does not silently change if URL validation is relaxed.
+        return false;
+    }
+}
+function configuredHeadersWithoutReserved(baseagent, configuredHeaders) {
+    const headers = {};
+    for (const [name, value] of Object.entries(configuredHeaders ?? {})) {
+        const normalizedName = name.toLowerCase();
+        if (!RESERVED_HEADER_NAMES.has(normalizedName)) {
+            headers[name] = value;
+            continue;
+        }
+        const warningKey = `${baseagent}:${normalizedName}`;
+        if (!warnedReservedHeaders.has(warningKey)) {
+            warnedReservedHeaders.add(warningKey);
+            logger.warn(`[RequestIdentity] Ignoring configured reserved header ${JSON.stringify(name)} for ${baseagent}; EvolCore manages this header at runtime`);
+        }
+    }
+    return headers;
+}
+export function buildModelRequestHeaders(input) {
+    const headers = configuredHeadersWithoutReserved(input.baseagent, input.configuredHeaders);
+    if (isOfficialModelEndpoint(input.baseagent, input.baseUrl))
+        return headers;
+    headers[EVOLCORE_REQUEST_HEADERS.version] = readInstalledEvolcoreVersion();
+    const agentAid = input.agentAid?.trim();
+    if (agentAid)
+        headers[EVOLCORE_REQUEST_HEADERS.agentAid] = agentAid;
+    headers[EVOLCORE_REQUEST_HEADERS.baseagent] = input.baseagent;
+    return headers;
+}
+export function _resetRequestIdentityWarningsForTests() {
+    warnedReservedHeaders.clear();
+}

package/dist/aun/aid/client.js

@@ -1,8 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { execFileSync } from 'child_process';
-import { isWindows } from '../../utils/cross-platform.js';
 /**
  * Suppress SDK console logs (DEBUG/INFO/WARN) in CLI context.
  * Call once at CLI entry point — NOT at module load time, to avoid
@@ -40,10 +38,9 @@ export function suppressSdkLogs() {
         return _origStderrWrite(chunk, encoding, callback);
     };
 }
-// ==================== Constants ====================
-export const MIN_AUN_CORE_SDK = [0, 4, 3];
+// ==================== SDK package ====================
+export const MIN_AUN_CORE_SDK = [0, 5, 6];
 export const AUN_CORE_SDK_PKG = '@agentunion/fastaun';
-// ==================== SDK & Environment ====================
 function compareVersion(a, min) {
     const parts = a.split('.').map(n => parseInt(n, 10));
     if (parts.length < 3 || parts.some(isNaN))
@@ -57,6 +54,7 @@ function compareVersion(a, min) {
 export function isAunSdkVersionOk(version) {
     return compareVersion(version, MIN_AUN_CORE_SDK);
 }
+/** Resolve only the SDK bundled in EvolCore's own dependency tree. */
 export function resolveAunCoreSdkPkg() {
     try {
         let dir = path.dirname(fileURLToPath(import.meta.url));
@@ -73,28 +71,20 @@ export function resolveAunCoreSdkPkg() {
             dir = parent;
         }
     }
-    catch { /* fall through */ }
-    try {
-        const npmCmd = isWindows ? 'npm.cmd' : 'npm';
-        const globalRoot = execFileSync(npmCmd, ['root', '-g'], {
-            encoding: 'utf-8', timeout: 10000, shell: isWindows,
-        }).trim();
-        const pkgPath = path.join(globalRoot, AUN_CORE_SDK_PKG, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const data = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            return { version: data.version, path: pkgPath };
-        }
-    }
-    catch { /* not found */ }
+    catch { /* invalid or missing package metadata */ }
     return null;
 }
+/**
+ * Compatibility guard retained for callers that explicitly check SDK readiness.
+ * The SDK is bundled with EvolCore and must never be installed independently.
+ */
 export async function ensureAunSdk() {
     const installed = resolveAunCoreSdkPkg();
     if (installed && isAunSdkVersionOk(installed.version))
         return;
-    const { npmInstallGlobal } = await import('../../utils/npm-ops.js');
-    console.log(`正在安装 ${AUN_CORE_SDK_PKG}@latest...`);
-    await npmInstallGlobal(`${AUN_CORE_SDK_PKG}@latest`);
+    const expected = MIN_AUN_CORE_SDK.join('.');
+    const detected = installed?.version ?? 'missing';
+    throw new Error(`${AUN_CORE_SDK_PKG} ${detected} is not the bundled SDK expected by EvolCore (>= ${expected}); reinstall or upgrade EvolCore`);
 }
 export function isAunSdkReady() {
     const installed = resolveAunCoreSdkPkg();

package/dist/aun/aid/managed-operation.js

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveRoot } from '../../paths.js';
+import { agentmdGet, agentmdPut } from './agentmd.js';
+import { aidLookup, aidShow } from './identity.js';
+import { isValidAid } from './validation.js';
+export class ManagedAidOperationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ManagedAidOperationError';
+    }
+}
+function normalizeAid(value) {
+    const aid = String(value || '').trim();
+    return aid.startsWith('@') ? aid.slice(1) : aid;
+}
+function hasOnlyOptionalJsonFormat(args, aidIndex) {
+    const suffix = args.slice(aidIndex + 1);
+    return suffix.length === 0 || (suffix.length === 2 && suffix[0] === '--format' && suffix[1] === 'json');
+}
+function parseAid(value) {
+    const aid = normalizeAid(value);
+    if (!aid)
+        return { ok: false, code: 'INVALID_ARGUMENT', reason: 'missing AID' };
+    if (!isValidAid(aid))
+        return { ok: false, code: 'INVALID_AID', reason: `invalid AID: ${aid}` };
+    return { ok: true, aid };
+}
+/**
+ * The daemon accepts only the self-scoped AID commands exposed to managed
+ * tasks. Parsing here is deliberately narrower than the standalone CLI.
+ */
+export function resolveManagedAidOperation(argv) {
+    const args = argv[0] === 'aid' ? argv.slice(1) : argv;
+    const subcommand = args[0];
+    if ((subcommand === 'show' || subcommand === 'lookup') && hasOnlyOptionalJsonFormat(args, 1)) {
+        const parsedAid = parseAid(args[1]);
+        if (!parsedAid.ok)
+            return parsedAid;
+        return {
+            ok: true,
+            command: {
+                kind: subcommand,
+                aid: parsedAid.aid,
+                operationId: `ec.aid.${subcommand}`,
+                canonicalArgv: ['aid', subcommand, parsedAid.aid],
+            },
+        };
+    }
+    if (subcommand === 'agentmd' && (args[1] === 'get' || args[1] === 'put') && hasOnlyOptionalJsonFormat(args, 2)) {
+        const parsedAid = parseAid(args[2]);
+        if (!parsedAid.ok)
+            return parsedAid;
+        const kind = `agentmd.${args[1]}`;
+        return {
+            ok: true,
+            command: {
+                kind,
+                aid: parsedAid.aid,
+                operationId: `ec.aid.${kind}`,
+                canonicalArgv: ['aid', 'agentmd', args[1], parsedAid.aid],
+            },
+        };
+    }
+    return {
+        ok: false,
+        code: 'NOT_ALLOWED',
+        reason: 'Managed AID operations only allow exact self-scoped show, lookup, agentmd get, or agentmd put commands with an optional --format json suffix',
+    };
+}
+const defaultDependencies = () => ({
+    root: resolveRoot(),
+    aidShow,
+    aidLookup,
+    agentmdGet,
+    agentmdPut,
+    existsSync: fs.existsSync,
+    readFileSync: fs.readFileSync,
+});
+/** Execute a validated AID operation from the daemon-owned host filesystem. */
+export async function executeManagedAidOperation(command, overrides = {}) {
+    const deps = { ...defaultDependencies(), ...overrides };
+    const aunPath = deps.root;
+    switch (command.kind) {
+        case 'show':
+            return { kind: command.kind, aid: command.aid, value: await deps.aidShow(command.aid, { aunPath }) };
+        case 'lookup':
+            return { kind: command.kind, aid: command.aid, value: await deps.aidLookup(command.aid) };
+        case 'agentmd.get':
+            return {
+                kind: command.kind,
+                aid: command.aid,
+                value: await deps.agentmdGet(command.aid, { aunPath, withVerification: true }),
+            };
+        case 'agentmd.put': {
+            const localPath = path.join(aunPath, 'AIDs', command.aid, 'agent.md');
+            if (!deps.existsSync(localPath)) {
+                throw new ManagedAidOperationError('LOCAL_AGENTMD_MISSING', `local agent.md not found: ${command.aid}`);
+            }
+            const content = deps.readFileSync(localPath, 'utf-8');
+            await deps.agentmdPut(content, { aid: command.aid, aunPath });
+            return { kind: command.kind, aid: command.aid, path: localPath };
+        }
+    }
+}

package/dist/aun/msg/group.js

@@ -13,6 +13,7 @@ import { readBestTaskRuntimeContext } from '../../cli/task-context.js';
 import { ipcQuery } from '../../ipc.js';
 import { resolvePaths } from '../../paths.js';
 import { AGENT_DELEGATION_TOKEN_ENV } from '../../core/auth/agent-delegation.js';
+import { normalizeAunMentionEntries } from './mention-schema.js';
 function buildGroupPayload(body) {
     return body.mode === 'text' ? { type: 'text', text: body.text } : { ...body.payload };
 }
@@ -189,8 +190,18 @@ export async function groupSend(args) {
                 break;
             }
         }
-        if (args.mentions && args.mentions.length > 0) {
-            payload.mentions = args.mentions;
+        const payloadMentions = Object.prototype.hasOwnProperty.call(payload, 'mentions')
+            ? normalizeAunMentionEntries(payload.mentions)
+            : undefined;
+        if (args.mentions !== undefined) {
+            const normalizedMentions = normalizeAunMentionEntries(args.mentions);
+            if (normalizedMentions.length > 0)
+                payload.mentions = normalizedMentions;
+            else if (payloadMentions !== undefined)
+                payload.mentions = payloadMentions;
+        }
+        else if (payloadMentions !== undefined) {
+            payload.mentions = payloadMentions;
         }
         applyGroupRoutingPayloadFields(payload, args, runtimeContext);
         const encrypt = resolveAunMessageEncrypt(args.encrypt);
@@ -305,8 +316,9 @@ export async function groupInfo(args) {
     }
 }
 export async function groupList(args) {
-    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    let conn;
     try {
+        conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
         const params = {};
         if (args.size !== undefined)
             params.size = args.size;
@@ -329,7 +341,8 @@ export async function groupList(args) {
         return formatRpcError(e);
     }
     finally {
-        await conn.close();
+        if (conn)
+            await conn.close();
     }
 }
 export async function groupUpdate(args) {
@@ -675,7 +688,7 @@ export async function groupUpdateRules(args) {
     }
 }
 const GROUP_RULES_FILE_PATH = '/rules.md';
-const MAX_GROUP_RULES_BYTES = 4 * 1024;
+export const MAX_GROUP_RULES_BYTES = 4 * 1024;
 const MTIME_TOLERANCE_MS = 1;
 export async function groupRulesFileGet(args) {
     return withAunClient(args.from, args, async (client) => {
@@ -742,13 +755,26 @@ export async function groupRulesFileGet(args) {
 }
 export async function groupRulesFileSet(args) {
     return withAunClient(args.from, args, async (client) => {
-        assertLocalRulesFile(args.filePath);
-        const upload = await client.group.fs.cp(args.filePath, `${args.groupId}:${GROUP_RULES_FILE_PATH}`, {
-            force: true,
-            overwrite: true,
-            parents: true,
-            contentType: 'text/markdown; charset=utf-8',
-        });
+        if ((args.filePath === undefined) === (args.content === undefined)) {
+            throw new Error('规则文件必须且只能提供 filePath 或 content');
+        }
+        let upload;
+        if (args.content !== undefined) {
+            const bytes = Buffer.from(args.content, 'utf8');
+            if (!args.content || bytes.byteLength > MAX_GROUP_RULES_BYTES || bytes.toString('utf8') !== args.content) {
+                throw new Error(`规则内容必须是非空 UTF-8，且不超过 ${MAX_GROUP_RULES_BYTES} bytes`);
+            }
+            upload = await uploadGroupRulesBytes(client, args.groupId, bytes);
+        }
+        else {
+            assertLocalRulesFile(args.filePath);
+            upload = await client.group.fs.cp(args.filePath, `${args.groupId}:${GROUP_RULES_FILE_PATH}`, {
+                force: true,
+                overwrite: true,
+                parents: true,
+                contentType: 'text/markdown; charset=utf-8',
+            });
+        }
         const published = await publishCurrentRulesFile(client, args.groupId, args.from);
         return { ...published, upload };
     });
@@ -984,6 +1010,49 @@ function assertLocalRulesFile(filePath) {
         throw new Error(`规则文件不是有效 UTF-8: ${errorMessage(e)}`);
     }
 }
+async function uploadGroupRulesBytes(client, groupId, bytes) {
+    const remotePath = `${groupId}:${GROUP_RULES_FILE_PATH}`;
+    const base = {
+        path: remotePath,
+        size_bytes: bytes.byteLength,
+        sha256: sha256Hex(bytes),
+        content_type: 'text/markdown; charset=utf-8',
+        force: true,
+        parents: true,
+    };
+    const check = await client.call('group.fs.check_upload', base);
+    if (isRecord(check) && check.within_limit === false) {
+        throw new Error('规则文件超过 group.fs 上传限制');
+    }
+    if (isRecord(check) && (check.instant === true || check.dedup_hit === true || check.skip_upload === true)) {
+        return client.call('group.fs.complete_upload', {
+            ...base,
+            skip_blob: true,
+            ...(check.session_id !== undefined ? { session_id: check.session_id } : {}),
+        });
+    }
+    const session = await client.call('group.fs.create_upload_session', base);
+    if (!isRecord(session))
+        throw new Error('group.fs.create_upload_session returned invalid response');
+    const uploadUrl = stringField(session, ['upload_url', 'url']);
+    if (!uploadUrl)
+        throw new Error('group.fs.create_upload_session did not return upload_url');
+    const headers = {};
+    if (isRecord(session.headers)) {
+        for (const [key, value] of Object.entries(session.headers)) {
+            if (value !== undefined && value !== null)
+                headers[key] = String(value);
+        }
+    }
+    if (!Object.keys(headers).some(key => key.toLowerCase() === 'content-type')) {
+        headers['Content-Type'] = base.content_type;
+    }
+    await client.group.fs.lowlevel.httpPut(uploadUrl, bytes, headers);
+    return client.call('group.fs.complete_upload', {
+        ...base,
+        ...((session.session_id ?? session.id) !== undefined ? { session_id: session.session_id ?? session.id } : {}),
+    });
+}
 async function readGroupRulesBytes(client, groupId) {
     const remoteRef = `${groupId}:${GROUP_RULES_FILE_PATH}`;
     const ticket = await client.call('group.fs.create_download_ticket', { path: remoteRef });