evolcore 0.0.22 → 0.0.24

package/dist/aun/msg/group.js

@@ -297,8 +297,16 @@ export async function groupAck(args) {
     }
 }
 export async function groupCreate(args) {
-    const store = await getAidStore({ slotId: args.slotId ?? SLOT.cli, aunPath: args.aunPath });
-    const conn = await loadClient(store, args.from);
+    return groupCreateWithDependencies(args, { getAidStore, loadClient });
+}
+/**
+ * Injectable boundary for the lifecycle call. Keeping the store/client
+ * construction outside the RPC makes the aidStore contract regression-testable
+ * without opening a real gateway connection.
+ */
+export async function groupCreateWithDependencies(args, dependencies) {
+    const store = await dependencies.getAidStore({ slotId: args.slotId ?? SLOT.cli, aunPath: args.aunPath });
+    const conn = await dependencies.loadClient(store, args.from);
     try {
         await conn.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
         const params = { name: args.name };
@@ -313,7 +321,7 @@ export async function groupCreate(args) {
             params.description = args.description;
         if (args.joinMode)
             params.join_mode = args.joinMode;
-        const result = await conn.createGroup(params);
+        const result = await conn.createGroup(params, { aidStore: store });
         return { ok: true, group: result?.group ?? result };
     }
     catch (e) {
@@ -510,7 +518,16 @@ export async function groupInvite(args) {
     try {
         for (const memberAid of args.members) {
             try {
-                await conn.call('group.add_member', { group_id: args.groupId, aid: memberAid });
+                // fastaun 0.5.12 introduced targeted invitations. The current gateway
+                // supports this lifecycle directly; do not bypass invitee consent with
+                // the immediate-membership group.add_member operation.
+                const inviteParams = {
+                    group_id: args.groupId,
+                    aid: memberAid,
+                };
+                if (args.memberType !== undefined)
+                    inviteParams.member_type = args.memberType;
+                await conn.call('group.invite_member', inviteParams);
                 added.push(memberAid);
             }
             catch (e) {
@@ -523,6 +540,50 @@ export async function groupInvite(args) {
         await conn.close();
     }
 }
+/** List pending targeted invitations for the authenticated AID. */
+export async function groupInvites(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = {};
+        if (args.page !== undefined)
+            params.page = args.page;
+        if (args.size !== undefined)
+            params.size = args.size;
+        const result = await conn.call('group.list_my_invites', params);
+        const invites = Array.isArray(result) ? result : Array.isArray(result?.invites)
+            ? result.invites
+            : Array.isArray(result?.items) ? result.items : [];
+        return {
+            ok: true,
+            invites,
+            page: typeof result?.page === 'number' ? result.page : args.page,
+            size: typeof result?.size === 'number' ? result.size : args.size,
+            nextCursor: typeof result?.next_cursor === 'string' ? result.next_cursor : null,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+async function groupInviteAction(args, method) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call(method, { invite_id: args.inviteId });
+        return { ok: true, group_id: result?.group_id ?? '', data: result };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export const groupAcceptInvite = (args) => groupInviteAction(args, 'group.accept_invite');
+export const groupRejectInvite = (args) => groupInviteAction(args, 'group.reject_invite');
+export const groupRevokeInvite = (args) => groupInviteAction(args, 'group.revoke_invite');
 export async function groupKick(args) {
     const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
     try {

package/dist/aun/msg/index.js

@@ -1,4 +1,4 @@
 export { msgSend, msgPull, msgAck, msgRecall, msgOnline, } from './p2p.js';
 export { msgHistory, MAX_MSG_HISTORY_LIMIT } from './history.js';
-export { groupSend, groupPull, groupAck, groupCreate, groupInfo, groupList, groupUpdate, groupDissolve, groupSuspend, groupResume, groupJoin, groupLeave, groupInvite, groupKick, groupMembers, groupOnline, groupSetRole, groupTransferOwner, groupBan, groupUnban, groupBanlist, groupRules, groupUpdateRules, groupRulesFileGet, groupRulesFileSet, groupRulesFilePublish, } from './group.js';
+export { groupSend, groupPull, groupAck, groupCreate, groupInfo, groupList, groupUpdate, groupDissolve, groupSuspend, groupResume, groupJoin, groupLeave, groupInvite, groupInvites, groupAcceptInvite, groupRejectInvite, groupRevokeInvite, groupKick, groupMembers, groupOnline, groupSetRole, groupTransferOwner, groupBan, groupUnban, groupBanlist, groupRules, groupUpdateRules, groupRulesFileGet, groupRulesFileSet, groupRulesFilePublish, } from './group.js';
 export { uploadFileAndBuildPayload, inferPayloadType, isValidPayloadType } from './upload.js';

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

@@ -7,7 +7,7 @@ import { isExplicitGroupId } from '../group-identity.js';
 import { isValidAid } from '../aid/validation.js';
 import { tryParseChannelKey } from '../../core/channel-loader.js';
 import { downloadGroupFsBytes } from '../group-fs-download.js';
-import { groupBan, groupBanlist, groupCreate, groupDissolve, groupInfo, groupInvite, groupJoin, groupKick, groupLeave, groupList, groupMembers, groupOnline, groupPull, groupAck, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from './group.js';
+import { groupBan, groupBanlist, groupCreate, groupDissolve, groupInfo, groupInvite, groupJoin, groupKick, groupLeave, groupList, groupMembers, groupOnline, groupPull, groupAck, groupAcceptInvite, groupInvites, groupRejectInvite, groupRevokeInvite, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from './group.js';
 /** Rules uploaded by a managed task are carried as bounded UTF-8 content. */
 export const MAX_MANAGED_GROUP_RULES_BYTES = 4 * 1024;
 const RELATION_GROUP_READ_KINDS = new Set([
@@ -32,7 +32,7 @@ export class ManagedGroupOperationError extends Error {
 }
 const GROUP_VALUE_FLAGS = new Set([
     '--format', '--after-seq', '--limit', '--visibility', '--description', '--join-mode', '--group-id',
-    '--name', '--page', '--size', '--mode', '--question', '--max-pending', '--message', '--answer', '--duration',
+    '--name', '--page', '--size', '--mode', '--question', '--max-pending', '--message', '--answer', '--duration', '--member-type',
 ]);
 function failGroup(code, reason) {
     return { ok: false, code, reason };
@@ -125,6 +125,37 @@ export function resolveManagedGroupOperation(argv) {
     if (!('positionals' in parsed))
         return parsed;
     const { positionals, values } = parsed;
+    if (sub === 'invites') {
+        const flagsError = onlyFlags(values, ['--page', '--size']);
+        if (flagsError)
+            return flagsError;
+        if (positionals.length !== 1)
+            return failGroup('INVALID_ARGUMENT', 'invites accepts exactly <from>');
+        const from = requiredAid(positionals[0], 'from AID');
+        if (typeof from !== 'string')
+            return from;
+        const page = numberFlag(values, '--page');
+        const size = numberFlag(values, '--size');
+        if (typeof page !== 'number' && page !== undefined)
+            return page;
+        if (typeof size !== 'number' && size !== undefined)
+            return size;
+        return command(sub, 'ec.group.invites', ['group', sub, from], from, { page, size });
+    }
+    if (sub === 'accept-invite' || sub === 'reject-invite' || sub === 'revoke-invite') {
+        const flagsError = onlyFlags(values, []);
+        if (flagsError)
+            return flagsError;
+        if (positionals.length !== 2)
+            return failGroup('INVALID_ARGUMENT', `${sub} accepts exactly <from> <invite-id>`);
+        const from = requiredAid(positionals[0], 'from AID');
+        if (typeof from !== 'string')
+            return from;
+        const inviteId = String(positionals[1]).trim();
+        if (!inviteId)
+            return failGroup('INVALID_ARGUMENT', 'missing invite-id');
+        return command(sub, `ec.group.${sub}`, ['group', sub, from, inviteId], from, { inviteId });
+    }
     if (sub === 'list') {
         const flagsError = onlyFlags(values, ['--size']);
         if (flagsError)
@@ -170,7 +201,7 @@ export function resolveManagedGroupOperation(argv) {
     if (simple.has(sub)) {
         const allowedFlags = {
             pull: ['--after-seq', '--limit'], ack: [], info: [], update: ['--name', '--description'], dissolve: [],
-            suspend: [], resume: [], join: ['--message', '--answer'], leave: [], invite: [], kick: [],
+            suspend: [], resume: [], join: ['--message', '--answer'], leave: [], invite: ['--member-type'], kick: [],
             members: ['--page', '--size'], online: [], role: [], owner: [], ban: ['--duration'], unban: [],
         };
         const flagsError = onlyFlags(values, allowedFlags[sub] ?? []);
@@ -216,7 +247,11 @@ export function resolveManagedGroupOperation(argv) {
                 if (typeof checked !== 'string')
                     return checked;
             }
+            const memberType = values.get('--member-type');
+            if (memberType !== undefined && memberType !== 'human' && memberType !== 'ai')
+                return failGroup('INVALID_ARGUMENT', 'invalid --member-type');
             extra.members = members;
+            extra.memberType = memberType;
         }
         else if (sub === 'kick' || sub === 'unban') {
             if (positionals.length !== 3)
@@ -357,7 +392,19 @@ export async function executeManagedGroupOperation(command, rulesContent) {
             result = await groupLeave({ from: command.from, groupId: command.groupId, ...opts });
             break;
         case 'invite':
-            result = await groupInvite({ from: command.from, groupId: command.groupId, members: command.members, ...opts });
+            result = await groupInvite({ from: command.from, groupId: command.groupId, members: command.members, memberType: command.memberType, ...opts });
+            break;
+        case 'invites':
+            result = await groupInvites({ from: command.from, page: command.page, size: command.size, ...opts });
+            break;
+        case 'accept-invite':
+            result = await groupAcceptInvite({ from: command.from, inviteId: command.inviteId, ...opts });
+            break;
+        case 'reject-invite':
+            result = await groupRejectInvite({ from: command.from, inviteId: command.inviteId, ...opts });
+            break;
+        case 'revoke-invite':
+            result = await groupRevokeInvite({ from: command.from, inviteId: command.inviteId, ...opts });
             break;
         case 'kick':
             result = await groupKick({ from: command.from, groupId: command.groupId, memberAid: command.memberAid, ...opts });
@@ -750,7 +797,12 @@ export function resolveManagedFsOperation(argv) {
         const destination = remoteOrError(positionals[1]);
         if (!('groupId' in destination))
             return destination;
-        const source = positionals[0].includes(':') ? remoteOrError(positionals[0]) : undefined;
+        // Windows absolute paths contain a drive-letter colon, but are local
+        // upload sources rather than managed group references.
+        const isWindowsAbsolutePath = /^[A-Za-z]:[\\/]/.test(positionals[0]);
+        const source = positionals[0].includes(':') && !isWindowsAbsolutePath
+            ? remoteOrError(positionals[0])
+            : undefined;
         if (source && !('groupId' in source))
             return source;
         if (source && source.groupId !== destination.groupId)

package/dist/aun/outbox.js

@@ -1,5 +1,6 @@
 import crypto from 'crypto';
-import { agentActivityOutboxPath, agentOutboxPath } from '../paths.js';
+import fs from 'fs';
+import { agentActivityOutboxPath, agentOutboxPath, legacyAgentActivityOutboxPath, legacyAgentOutboxPath, legacyFlatOutboxPath, } from '../paths.js';
 import { atomicRead, atomicWrite } from '../utils/atomic-write.js';
 import { isDeliveryTarget, isDeliveryTargetForChannel, sameDeliveryTarget } from '../core/message/message-utils.js';
 export const DEFAULT_OUTBOX_MAX_ENTRIES = 200;
@@ -10,11 +11,13 @@ const MAX_TERMINAL_ENTRIES_PER_AID = 100;
 const QUEUE_CONFIG = {
     default: {
         file: agentOutboxPath,
+        legacyFiles: aid => [legacyAgentOutboxPath(aid), legacyFlatOutboxPath(aid)],
         maxEntries: DEFAULT_OUTBOX_MAX_ENTRIES,
         defaultTtl: DEFAULT_OUTBOX_TTL_MS,
     },
     activity: {
         file: agentActivityOutboxPath,
+        legacyFiles: aid => [legacyAgentActivityOutboxPath(aid)],
         maxEntries: ACTIVITY_OUTBOX_MAX_ENTRIES,
         defaultTtl: ACTIVITY_OUTBOX_TTL_MS,
     },
@@ -28,6 +31,55 @@ export function defaultTtl(queue = 'default') {
 function outboxFile(aid, queue = 'default') {
     return queueConfig(queue).file(aid);
 }
+const migratedOutboxes = new Set();
+function parseEntriesFile(file) {
+    try {
+        const content = atomicRead(file)?.trim();
+        if (!content)
+            return [];
+        return content.split('\n').map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        }).filter((entry) => entry !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/** Import old outbox layouts without deleting their recovery copies. */
+function ensureOutboxMigrated(aid, queue) {
+    const canonical = outboxFile(aid, queue);
+    const key = canonical;
+    if (migratedOutboxes.has(key))
+        return;
+    const merged = fs.existsSync(canonical) ? parseEntriesFile(canonical) : [];
+    const ids = new Set(merged.map(entry => entry.id));
+    let changed = false;
+    for (const legacy of queueConfig(queue).legacyFiles(aid)) {
+        if (legacy === canonical || !fs.existsSync(legacy))
+            continue;
+        for (const entry of parseEntriesFile(legacy)) {
+            if (ids.has(entry.id))
+                continue;
+            ids.add(entry.id);
+            merged.push(entry);
+            changed = true;
+        }
+    }
+    if (!changed) {
+        migratedOutboxes.add(key);
+        return;
+    }
+    const content = merged.length > 0
+        ? merged.map(entry => JSON.stringify(entry)).join('\n') + '\n'
+        : '';
+    atomicWrite(canonical, content);
+    migratedOutboxes.add(key);
+}
 function entryQueue(entry) {
     return entry.queue ?? 'default';
 }
@@ -50,25 +102,11 @@ export function isDeliveryForChannel(value, channelId) {
     return isDeliveryTargetForChannel(value, channelId);
 }
 function readEntries(aid, queue = 'default') {
-    const file = outboxFile(aid, queue);
-    try {
-        const content = atomicRead(file)?.trim();
-        if (!content)
-            return [];
-        return content.split('\n').map(line => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return null;
-            }
-        }).filter((e) => e !== null);
-    }
-    catch {
-        return [];
-    }
+    ensureOutboxMigrated(aid, queue);
+    return parseEntriesFile(outboxFile(aid, queue));
 }
 function writeEntries(aid, entries, queue = 'default') {
+    ensureOutboxMigrated(aid, queue);
     const file = outboxFile(aid, queue);
     const boundedEntries = trimFinalEntries(entries);
     const content = boundedEntries.length > 0

package/dist/aun/rpc/client.js

@@ -3,11 +3,17 @@ export async function createShortConnection(aid, opts) {
     const store = await getAidStore({ slotId: opts?.slotId ?? SLOT.cli, aunPath: opts?.aunPath });
     try {
         const client = await loadClient(store, aid);
-        await client.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
+        await client.connect({ connection_kind: 'short', short_ttl_ms: opts?.shortTtlMs ?? 30000, auto_reconnect: false });
         return {
             async call(method, params) {
                 return client.call(method, params);
             },
+            group: {
+                createInviteCode: (params) => client.group.createInviteCode(params),
+                listInviteCodes: (params) => client.group.listInviteCodes(params),
+                useInviteCode: (params) => client.group.useInviteCode(params),
+                revokeInviteCode: (params) => client.group.revokeInviteCode(params),
+            },
             async close() {
                 try {
                     await client.close();