evolcore 0.0.11 → 0.0.12

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 });