evolcore 0.0.26 → 0.0.28

package/dist/aun/group/history.js

@@ -0,0 +1,303 @@
+import fs from 'fs';
+import path from 'path';
+import { createHash } from 'crypto';
+import { TextDecoder } from 'util';
+import { isValidAid } from '../aid/validation.js';
+import { normalizeGroupAid } from './identity.js';
+import { resolvePaths } from '../../paths.js';
+import { appendJsonlDurable, chatDirPath } from '../../core/session/session-fs-store.js';
+import { isTransientProtocolMessage, messageLogPath } from '../../core/message/message-log.js';
+export class GroupHistoryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'GroupHistoryError';
+    }
+}
+const MAX_PAGE_BYTES = 24 * 1024;
+/** Shared strict grammar for standalone and daemon-managed history. */
+export function parseGroupHistoryArgs(argv) {
+    const args = argv[0] === 'history' ? argv.slice(1) : argv;
+    const from = args[0];
+    if (!from || !isValidAid(from))
+        fail('INVALID_ARGUMENT', 'history 需要有效的 self AID');
+    if (!args[1])
+        fail('INVALID_ARGUMENT', 'history 需要群 AID');
+    const groupId = normalizeGroupAid(args[1], from.slice(from.indexOf('.') + 1));
+    const values = new Map();
+    const flags = new Set(['--unread', '--all']);
+    const named = new Set(['--limit', '--thread', '--before', '--after', '--direction', '--format', '--message', '--offset']);
+    for (let i = 2; i < args.length; i++) {
+        const flag = args[i];
+        if (values.has(flag))
+            fail('INVALID_ARGUMENT', flag + ' 不能重复');
+        if (flags.has(flag))
+            values.set(flag, 'true');
+        else if (named.has(flag)) {
+            const value = args[++i];
+            if (!value || value.startsWith('--'))
+                fail('INVALID_ARGUMENT', flag + ' 缺少值');
+            values.set(flag, value);
+        }
+        else
+            fail('INVALID_ARGUMENT', '不支持的 history 参数: ' + flag);
+    }
+    if (values.has('--unread') && values.has('--all'))
+        fail('INVALID_ARGUMENT', '--unread 与 --all 互斥');
+    if (!values.has('--unread') && !values.has('--all')) {
+        fail('INVALID_ARGUMENT', 'history 必须明确指定 --unread 或 --all');
+    }
+    if (values.has('--format') && !['text', 'json'].includes(values.get('--format')))
+        fail('INVALID_ARGUMENT', '--format 仅支持 text|json');
+    if ((values.has('--message') || values.has('--offset')) && !values.has('--all')) {
+        fail('INVALID_ARGUMENT', '--message/--offset 仅支持 --all');
+    }
+    if (values.has('--offset') && !values.has('--message'))
+        fail('INVALID_ARGUMENT', '--offset 需要 --message');
+    const offset = values.has('--offset') ? Number(values.get('--offset')) : undefined;
+    if (offset !== undefined && (!Number.isSafeInteger(offset) || offset < 0))
+        fail('INVALID_ARGUMENT', '无效 offset');
+    const limit = values.has('--limit') ? Number(values.get('--limit')) : undefined;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit < 1 || limit > 500))
+        fail('INVALID_ARGUMENT', '--limit 必须是 1–500');
+    const direction = values.get('--direction');
+    if (direction && !['in', 'out', 'all'].includes(direction))
+        fail('INVALID_ARGUMENT', '无效 direction');
+    const time = (flag) => {
+        const raw = values.get(flag);
+        if (raw === undefined)
+            return undefined;
+        const result = /^\d+$/.test(raw) ? Number(raw) : Date.parse(raw);
+        if (!Number.isFinite(result) || result < 0)
+            fail('INVALID_ARGUMENT', flag + ' 需要有效时间');
+        return result;
+    };
+    const before = time('--before');
+    const after = time('--after');
+    if (before !== undefined && after !== undefined && after >= before)
+        fail('INVALID_ARGUMENT', '--after 必须早于 --before');
+    return {
+        from, groupId, unread: values.has('--unread'), thread: values.get('--thread'),
+        limit, direction, before, after, message: values.get('--message'), offset,
+    };
+}
+const DETAIL_BYTES = 8 * 1024;
+const MAX_LINE_BYTES = 16 * 1024 * 1024;
+const decoder = new TextDecoder('utf-8', { fatal: true });
+const digest = (value) => createHash('sha256').update(value).digest('hex');
+const fail = (code, message) => { throw new GroupHistoryError(code, message); };
+/** Bounded line reader. Partial tails are retriable; malformed complete lines fail visibly. */
+function* lines(file, snapshot) {
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    try {
+        const end = Math.min(snapshot ?? Number.MAX_SAFE_INTEGER, fs.fstatSync(fd).size);
+        const buffer = Buffer.alloc(64 * 1024);
+        let pending = Buffer.alloc(0);
+        let position = 0;
+        while (position < end) {
+            const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, end - position), position);
+            if (!count)
+                break;
+            position += count;
+            pending = Buffer.concat([pending, buffer.subarray(0, count)]);
+            let start = 0;
+            let newline;
+            while ((newline = pending.indexOf(10, start)) >= 0) {
+                if (newline - start > MAX_LINE_BYTES)
+                    fail('HISTORY_RECORD_TOO_LARGE', '历史单条记录超过 16 MiB');
+                const line = decoder.decode(pending.subarray(start, newline));
+                if (line.trim())
+                    yield line;
+                start = newline + 1;
+            }
+            pending = pending.subarray(start);
+            if (pending.length > MAX_LINE_BYTES)
+                fail('HISTORY_RECORD_TOO_LARGE', '历史单条记录超过 16 MiB');
+        }
+        if (pending.length)
+            fail('HISTORY_INCOMPLETE', '历史文件末行尚未完整写入，请稍后重试');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function json(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return fail('HISTORY_CORRUPT', '历史文件含损坏的完整 JSONL 行，未推进已读状态');
+    }
+}
+function generation(file) {
+    try {
+        const stat = fs.statSync(file);
+        // First complete record plus file identity stays stable across append, but changes on replacement.
+        let first = '';
+        for (const line of lines(file)) {
+            first = line;
+            break;
+        }
+        return digest(JSON.stringify([stat.dev, stat.ino, stat.birthtimeMs, digest(first)]));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return 'missing';
+        throw error;
+    }
+}
+function* records(file, args) {
+    let size;
+    try {
+        size = fs.statSync(file).size;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    const seen = new Set();
+    for (const line of lines(file, size)) {
+        const entry = json(line);
+        if (!entry || entry.chatType !== 'group' || entry.groupId !== args.groupId
+            || (entry.dir !== 'in' && entry.dir !== 'out') || typeof entry.content !== 'string'
+            || typeof entry.from !== 'string' || typeof entry.to !== 'string'
+            || !Number.isFinite(entry.ts) || typeof entry.msgType !== 'string'
+            || (entry.dir === 'in' ? entry.to !== args.from : entry.from !== args.from)
+            || isTransientProtocolMessage(entry))
+            continue;
+        const identity = entry.msgId ? JSON.stringify([entry.dir, entry.msgId]) : digest(line);
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        // Keep the existing read-state fingerprints compatible; redelivery seq/time do not change identity.
+        const hash = digest(JSON.stringify([identity, entry.threadId ?? null, entry.from, entry.to,
+            entry.msgType, entry.encrypt, entry.content, entry.payloadSummary, entry.groupAttention, entry.groupDelivery]));
+        yield { entry, hash };
+    }
+}
+function readState(chatDir, logGeneration) {
+    const read = new Set();
+    for (const line of lines(path.join(chatDir, 'group-history-read.jsonl'))) {
+        const event = json(line);
+        if (!event || event.version !== 1 || typeof event.generation !== 'string' || !Array.isArray(event.records)
+            || !event.records.every(value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value))) {
+            fail('HISTORY_STATE_CORRUPT', '群历史已读状态损坏');
+        }
+        if (event.generation === logGeneration)
+            for (const value of event.records)
+                read.add(value);
+    }
+    return read;
+}
+function matchThread(entry, thread) {
+    return thread === 'all' || (thread === 'main' ? !entry.threadId : entry.threadId === thread);
+}
+function utf8Prefix(content, bytes) {
+    const buffer = Buffer.from(content);
+    let end = Math.min(bytes, buffer.length);
+    while (end > 0 && end < buffer.length && (buffer[end] & 0xc0) === 0x80)
+        end--;
+    return buffer.subarray(0, end).toString('utf8');
+}
+/** Local-only history. Unread queries record only the messages selected for this result. */
+export function groupHistory(args, context = {}) {
+    if (!isValidAid(args.from))
+        fail('INVALID_SELF_AID', '无效 self AID');
+    args = { ...args, groupId: normalizeGroupAid(args.groupId, args.from.slice(args.from.indexOf('.') + 1)) };
+    const limit = args.limit ?? 50;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 500)
+        fail('INVALID_LIMIT', 'limit 必须是 1–500');
+    const thread = args.thread ?? context.defaultThread ?? 'all';
+    if (!thread || thread.length > 512 || /[\x00-\x1f]/.test(thread))
+        fail('INVALID_THREAD', '无效 thread');
+    const chatDir = chatDirPath(context.sessionsDir ?? resolvePaths().sessionsDir, 'aun', args.groupId, args.from);
+    const file = messageLogPath(chatDir);
+    const base = { ok: true, source: 'local', self_aid: args.from, group_id: args.groupId };
+    const logGeneration = args.unread ? generation(file) : '';
+    const read = args.unread ? readState(chatDir, logGeneration) : new Set();
+    if (args.message) {
+        if (args.unread)
+            fail('INVALID_ARGUMENT', '--message 仅支持 --all');
+        const offset = args.offset ?? 0;
+        if (!Number.isSafeInteger(offset) || offset < 0)
+            fail('INVALID_ARGUMENT', '无效 offset');
+        for (const { entry } of records(file, args)) {
+            if (entry.msgId !== args.message || !matchThread(entry, thread))
+                continue;
+            const content = Buffer.from(entry.content);
+            if (offset > content.length || (offset < content.length && (content[offset] & 0xc0) === 0x80)) {
+                fail('INVALID_OFFSET', 'offset 必须是正文内的 UTF-8 字节边界');
+            }
+            const chunk = utf8Prefix(content.subarray(offset).toString('utf8'), DETAIL_BYTES);
+            const next = offset + Buffer.byteLength(chunk);
+            return { ...base, mode: 'message', msgId: entry.msgId, thread_id: entry.threadId ?? null,
+                offset, content: chunk, content_truncated: next < content.length,
+                next_offset: next < content.length ? next : null };
+        }
+        return fail('MESSAGE_NOT_FOUND', '本地当前范围内找不到该消息');
+    }
+    const selected = [];
+    let hasMore = false;
+    let bytes = 0;
+    for (const record of records(file, args)) {
+        const { entry } = record;
+        if (!matchThread(entry, thread)
+            || (args.direction && args.direction !== 'all' && entry.dir !== args.direction)
+            || (args.after !== undefined && entry.ts <= args.after)
+            || (args.before !== undefined && entry.ts >= args.before))
+            continue;
+        if (args.unread && (entry.dir !== 'in' || entry.groupDelivery !== 'filtered'
+            || entry.groupAttention !== 'unmentioned' || read.has(record.hash)))
+            continue;
+        const size = Buffer.byteLength(JSON.stringify(entry));
+        if (args.unread) {
+            if (selected.length >= limit || (selected.length && bytes + size > MAX_PAGE_BYTES)) {
+                hasMore = true;
+                break;
+            }
+            selected.push(record);
+            bytes += size;
+        }
+        else {
+            selected.push(record);
+            bytes += size;
+            while (selected.length > limit || (selected.length > 1 && bytes > MAX_PAGE_BYTES)) {
+                bytes -= Buffer.byteLength(JSON.stringify(selected.shift().entry));
+                hasMore = true;
+            }
+        }
+    }
+    const messages = selected.map(({ entry }) => {
+        if (Buffer.byteLength(JSON.stringify(entry)) <= MAX_PAGE_BYTES)
+            return entry;
+        const preview = utf8Prefix(entry.content, DETAIL_BYTES);
+        return {
+            ts: entry.ts, time: entry.time, dir: entry.dir, from: entry.from, to: entry.to,
+            chatType: entry.chatType, groupId: entry.groupId, threadId: entry.threadId, msgId: entry.msgId,
+            msgType: entry.msgType, encrypt: entry.encrypt, content: preview, content_truncated: true,
+            next_offset: Buffer.byteLength(preview),
+        };
+    });
+    const result = {
+        ...base, mode: args.unread ? 'unread' : 'all', thread_id: thread,
+        count: messages.length, has_more: hasMore, messages,
+    };
+    // Persist the exact returned selection, never an entire group/time/seq watermark.
+    // Query errors above leave state untouched; --all never writes read state.
+    if (args.unread && selected.length) {
+        appendJsonlDurable(path.join(chatDir, 'group-history-read.jsonl'), {
+            version: 1, generation: logGeneration, records: selected.map(record => record.hash), confirmedAt: Date.now(),
+        });
+    }
+    return result;
+}

package/dist/aun/group/identity.js

@@ -0,0 +1,43 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const requireSdk = createRequire(import.meta.url);
+let groupValidator;
+/** Validate a group command argument, expanding a local base to a full AID. */
+export function normalizeGroupAid(value, localIssuer) {
+    // The SDK still converts group.issuer/base. EvolCore no longer accepts it.
+    if (value.includes('/')) {
+        throw new Error('Path-style group IDs are not supported; use base.issuer');
+    }
+    // Keep contact/config type hints free of SDK startup side effects (SQLite,
+    // etc.). Node >=22.16 supports synchronous ESM loading; resolve the SDK's
+    // public import entry because the package has no CommonJS export condition.
+    groupValidator ??= requireSdk(fileURLToPath(import.meta.resolve('@agentunion/fastaun'))).validateGroupAIDFormat;
+    const aid = groupValidator(value, { localIssuer });
+    const dot = aid.indexOf('.');
+    if (dot <= 0 || dot === aid.length - 1) {
+        throw new Error(`Group AID must include an issuer: ${value}`);
+    }
+    return aid;
+}
+/** Compare identities only in a context already known to be an AUN group. */
+export function sameGroupAid(left, right) {
+    try {
+        return normalizeGroupAid(left) === normalizeGroupAid(right);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Legacy group identity hint, NOT a format validator. Canonical group AIDs and
+ * private AIDs share a syntax; prefer trusted chat/targetKind information.
+ * Do not broaden this predicate to every SDK-valid group argument.
+ */
+export function isExplicitGroupId(value) {
+    const id = value.trim();
+    if (!id)
+        return false;
+    return /^\d+\.[a-z0-9.-]+$/i.test(id)
+        || /^grp_[a-z0-9_-]+$/i.test(id)
+        || /^g-[a-z0-9_-]+(?:[.@][a-z0-9.-]+)?$/i.test(id);
+}

package/dist/aun/group/index.js

@@ -0,0 +1,5 @@
+export * from './operations.js';
+export * from './history.js';
+export * from './identity.js';
+export * from './index-rpc.js';
+export * from './fs-download.js';

package/dist/aun/{msg/group.js → group/operations.js}

@@ -1,20 +1,21 @@
 import fs from 'fs';
 import path from 'path';
-import { createHash } from 'crypto';
+import { createHash, randomInt } from 'crypto';
 import { TextDecoder } from 'util';
 import { createShortConnection } from '../rpc/index.js';
 import { getAidStore, loadClient, SLOT } from '../aid/store.js';
-import { uploadFileAndBuildPayload } from './upload.js';
-import { daemonTaskSendIpcTimeoutMs, resolveAunMessageEncrypt } from './p2p.js';
-import { checkGroupIndex, getGroupIndex } from './group-index.js';
+import { uploadFileAndBuildPayload } from '../msg/upload.js';
+import { daemonTaskSendIpcTimeoutMs, resolveAunMessageEncrypt } from '../msg/p2p.js';
+import { checkGroupIndex, getGroupIndex } from './index-rpc.js';
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from '../../core/message/message-log.js';
 import { chatDirPath } from '../../core/session/session-fs-store.js';
 import { normalizeCodexTextPayload, readBestTaskRuntimeContext } from '../../cli/task-context.js';
-import { ipcQuery } from '../../ipc.js';
+import { ipcQuery, IpcTransportError } 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';
-import { downloadGroupFsBytes } from '../group-fs-download.js';
+import { readDelegationCredential } from '../../core/auth/agent-delegation.js';
+import { normalizeAunMentionEntries, withAunAttention } from '../msg/mention-schema.js';
+import { downloadGroupFsBytes } from './fs-download.js';
+import { normalizeGroupAid, sameGroupAid } from './identity.js';
 /** Map a group directory probe failure to a stable Menu protocol code. */
 export function groupDirectoryErrorCode(rawCode, error) {
     if (rawCode === -33001 || rawCode === -33005 || rawCode === -33006 || rawCode === '-33001' || rawCode === '-33005' || rawCode === '-33006')
@@ -31,7 +32,8 @@ export function groupDirectoryErrorCode(rawCode, error) {
     return 'TEMPORARILY_UNAVAILABLE';
 }
 function buildGroupPayload(body) {
-    return body.mode === 'text' ? { type: 'text', text: body.text } : { ...body.payload };
+    const payload = body.mode === 'text' ? { type: 'text', text: body.text } : { ...body.payload };
+    return withAunAttention(payload);
 }
 function groupMessageLogContent(body) {
     return body.mode === 'text' ? body.text
@@ -42,7 +44,8 @@ function isCurrentGroupRuntime(args, runtimeContext) {
     return runtimeContext?.channel === 'aun'
         && runtimeContext.chatType === 'group'
         && runtimeContext.selfAid === args.from
-        && runtimeContext.channelId === args.groupId;
+        && !!runtimeContext.channelId
+        && (runtimeContext.channelId === args.groupId || sameGroupAid(runtimeContext.channelId, args.groupId));
 }
 function groupThreadId(args, payload, runtimeContext) {
     const payloadThread = typeof payload?.thread_id === 'string' && payload.thread_id.trim()
@@ -89,7 +92,7 @@ function appendGroupSendOutboundLog(args, messageId, payload, runtimeContext, en
 }
 async function tryDaemonGroupSend(args, payload, runtimeContext, file) {
     const delegatedTask = !!process.env.EVOLCORE_SESSION_ID
-        || !!process.env[AGENT_DELEGATION_TOKEN_ENV];
+        || !!readDelegationCredential();
     if (!runtimeContext) {
         return delegatedTask
             ? { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task runtime context is unavailable' }
@@ -117,9 +120,13 @@ async function tryDaemonGroupSend(args, payload, runtimeContext, file) {
         returnPolicy: args.returnPolicy,
         originSessionId: runtimeContext.sessionId,
         originMessageId: runtimeContext.messageId,
-        delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+        delegationToken: readDelegationCredential(),
         log: groupSendLogMetadata(args, payload, runtimeContext),
-    }, daemonTaskSendIpcTimeoutMs(!!file));
+    }, daemonTaskSendIpcTimeoutMs(!!file), { throwOnError: true }).catch(error => {
+        if (!(error instanceof IpcTransportError))
+            throw error;
+        return { ok: false, code: error.code, error: error.message };
+    });
     return response ?? {
         ok: false,
         code: 'AUN_DAEMON_UNAVAILABLE',
@@ -224,6 +231,7 @@ export async function groupSend(args) {
         }
         applyGroupRoutingPayloadFields(payload, args, runtimeContext);
         const encrypt = resolveAunMessageEncrypt(args.encrypt);
+        payload = withAunAttention(payload);
         const sendParams = { group_id: args.groupId, payload, encrypt };
         const result = await conn.call('group.send', sendParams);
         const messageId = typeof result?.message?.message_id === 'string' && result.message.message_id.trim()
@@ -296,6 +304,8 @@ export async function groupAck(args) {
         await conn.close();
     }
 }
+// ==================== Lifecycle ====================
+const MAX_GROUP_NAME_ATTEMPTS = 5;
 export async function groupCreate(args) {
     return groupCreateWithDependencies(args, { getAidStore, loadClient });
 }
@@ -305,30 +315,68 @@ export async function groupCreate(args) {
  * without opening a real gateway connection.
  */
 export async function groupCreateWithDependencies(args, dependencies) {
+    let requestedGroupAid;
+    try {
+        if (args.groupId !== undefined) {
+            requestedGroupAid = normalizeGroupAid(args.groupId, args.from.slice(args.from.indexOf('.') + 1));
+        }
+    }
+    catch (error) {
+        return { ok: false, code: 'INVALID_GROUP', error: errorMessage(error) };
+    }
     const store = await dependencies.getAidStore({ slotId: args.slotId ?? SLOT.cli, aunPath: args.aunPath });
-    const conn = await dependencies.loadClient(store, args.from);
+    let conn;
     try {
+        conn = await dependencies.loadClient(store, args.from);
         await conn.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
-        const params = { name: args.name };
-        if (args.groupId)
-            params.group_id = args.groupId;
-        const groupName = groupNameFromGroupId(args.groupId);
-        if (groupName)
-            params.group_name = groupName;
-        if (args.visibility)
-            params.visibility = args.visibility;
-        if (args.description)
-            params.description = args.description;
-        if (args.joinMode)
-            params.join_mode = args.joinMode;
-        const result = await conn.createGroup(params, { aidStore: store });
-        return { ok: true, group: result?.group ?? result };
+        const attempts = requestedGroupAid ? 1 : MAX_GROUP_NAME_ATTEMPTS;
+        const randomGroupNumber = dependencies.randomGroupNumber ?? (() => randomInt(10000, 100000));
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            // Use the service's issuer for default names, just as SDK named-group creation does.
+            const groupName = requestedGroupAid?.split('.')[0]
+                ?? `g-${randomGroupNumber()}`;
+            const params = { name: args.name, group_name: groupName };
+            if (requestedGroupAid)
+                params.group_id = requestedGroupAid;
+            if (args.visibility)
+                params.visibility = args.visibility;
+            if (args.description)
+                params.description = args.description;
+            if (args.joinMode)
+                params.join_mode = args.joinMode;
+            let result;
+            try {
+                result = await conn.createGroup(params, { aidStore: store });
+            }
+            catch (error) {
+                // Only a definite identity collision permits a NEW name. An interrupted
+                // create/import may already have created a group and must not be repeated.
+                if (!requestedGroupAid && attempt + 1 < attempts && isGroupNameConflict(error))
+                    continue;
+                throw error;
+            }
+            const group = normalizeGroupInfo(result?.group ?? result);
+            const actualAid = normalizeGroupAid(group.group_id);
+            const differs = requestedGroupAid ? actualAid !== requestedGroupAid : actualAid.split('.')[0] !== groupName;
+            return {
+                ok: true,
+                group,
+                ...(differs ? {
+                    requested_group_aid: requestedGroupAid ?? groupName,
+                    warning: `请求的群标识 ${requestedGroupAid ?? groupName} 与实际创建结果不同；后续请使用 ${actualAid}`,
+                } : {}),
+            };
+        }
+        throw new Error(`Unable to allocate a group name after ${attempts} attempts`);
     }
     catch (e) {
         return formatRpcError(e);
     }
     finally {
-        await conn.close();
+        try {
+            await conn?.close();
+        }
+        catch { }
         try {
             store.close();
         }
@@ -765,6 +813,86 @@ export async function groupBanlist(args) {
         await conn.close();
     }
 }
+export async function groupBlock(args) {
+    let conn;
+    try {
+        conn = await createShortConnection(args.from, args);
+        const params = { group_id: args.groupId, subject: args.memberAid };
+        if (args.reason !== undefined)
+            params.reason = args.reason;
+        const data = await conn.call('group.block', params);
+        return { ok: true, group_id: args.groupId, data };
+    }
+    catch (error) {
+        return formatRpcError(error);
+    }
+    finally {
+        await conn?.close();
+    }
+}
+export async function groupUnblock(args) {
+    let conn;
+    try {
+        conn = await createShortConnection(args.from, args);
+        const data = await conn.call('group.unblock', { group_id: args.groupId, subject: args.memberAid });
+        return { ok: true, group_id: args.groupId, data };
+    }
+    catch (error) {
+        return formatRpcError(error);
+    }
+    finally {
+        await conn?.close();
+    }
+}
+export async function groupBlocklist(args) {
+    let conn;
+    try {
+        conn = await createShortConnection(args.from, args);
+        const result = await conn.call('group.get_blocklist', { group_id: args.groupId });
+        return {
+            ok: true, group_id: result?.group_aid ?? result?.group_id ?? args.groupId,
+            items: result?.items ?? [], total: result?.total, page: result?.page, size: result?.size,
+        };
+    }
+    catch (error) {
+        return formatRpcError(error);
+    }
+    finally {
+        await conn?.close();
+    }
+}
+export async function groupReportStatus(args) {
+    let conn;
+    try {
+        conn = await createShortConnection(args.from, args);
+        const data = await conn.call('group.report_status', {
+            group_id: args.groupId, online_status: args.onlineStatus, work_status: args.workStatus,
+        });
+        return { ok: true, group_id: args.groupId, data };
+    }
+    catch (error) {
+        return formatRpcError(error);
+    }
+    finally {
+        await conn?.close();
+    }
+}
+export async function groupMemberStatuses(args) {
+    let conn;
+    try {
+        conn = await createShortConnection(args.from, args);
+        const result = await conn.call('group.get_member_statuses', { group_id: args.groupId });
+        return {
+            ok: true, group_id: result?.group_aid ?? result?.group_id ?? args.groupId, items: result?.items ?? [],
+        };
+    }
+    catch (error) {
+        return formatRpcError(error);
+    }
+    finally {
+        await conn?.close();
+    }
+}
 export async function groupRules(args) {
     const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
     try {
@@ -1406,13 +1534,8 @@ function errorMessage(e) {
         return String(e.message);
     return String(e);
 }
-function groupNameFromGroupId(groupId) {
-    if (!groupId)
-        return undefined;
-    const raw = String(groupId).trim().toLowerCase();
-    const first = raw.split(/[.@/]/, 1)[0] ?? '';
-    const slug = first.startsWith('g-') ? first.slice(2) : first;
-    if (/^[a-z0-9][a-z0-9_-]{3,63}$/.test(slug))
-        return slug;
-    return undefined;
+function isGroupNameConflict(error) {
+    const value = error;
+    return value?.code === -32052
+        || value?.stringCode === 'IDENTITY_CONFLICT' || value?.code === 'IDENTITY_CONFLICT';
 }