@aopslabs/aops 0.3.16 → 0.3.18

package/dist/commands/chatv3.js

@@ -28,12 +28,20 @@ const CHATV3_COMMAND_TREE = {
     listen: null,
     leave: null,
     binding: new Set(['add', 'list', 'remove']),
-    member: new Set(['list', 'remove']),
+    member: new Set(['list', 'remove', 'restore']),
     presence: new Set(['list', 'set']),
-    room: new Set(['brief', 'summary']),
+    room: new Set(['brief', 'summary', 'create', 'list', 'members', 'join', 'leave']),
     session: new Set(['list', 'get', 'forget']),
     help: null,
 };
+const CHATV3_ROOM_MEMBERS_UNSUPPORTED_HINT = 'This server does not expose room-scoped participation yet (requires chatv3 domain with the chatv3.room.members op); retry without --room or upgrade the server.';
+function withRoomMembersSupportHint(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/not_found|\b404\b/i.test(message)) {
+        throw new Error(`${message} — ${CHATV3_ROOM_MEMBERS_UNSUPPORTED_HINT}`);
+    }
+    throw error instanceof Error ? error : new Error(message);
+}
 function toInteger(value, label) {
     if (value === undefined)
         return 0;
@@ -508,6 +516,9 @@ async function loadRuntime(options, sessionId) {
         storePath: options.storePath,
         owner: options.sessionOwner,
     });
+    if (loaded.staleEpochKeys && loaded.staleEpochKeys.length > 0) {
+        process.stderr.write(`[chatv3] Dropped ${loaded.staleEpochKeys.length} stored room key(s) that no longer decrypt with the local session.key; refreshing from the server.\n`);
+    }
     const serverBaseUrl = normalizeNonEmpty(options.apiBaseUrl) ?? loaded.record.serverBaseUrl;
     const keyStore = new MemoryKeyStore();
     if (loaded.secrets.wrapSecret) {
@@ -941,14 +952,18 @@ export async function runChatv3Join(invite, options = {}) {
         }, { storePath, owner: options.sessionOwner });
         record = summarizeChatv3Session(saved);
     }
+    const selfMember = members.find((member) => member.handle === handle);
     buildEnvelope({
         options,
         command: 'chatv3.join',
         serverBaseUrl,
         input: { invite: 'redacted', handle, session: sessionId, saveSession: options.saveSession === true, mode: parsed.mode ?? 'e2e' },
-        artifacts: compactPayload({ sessionId, channelId: channel.id, activeRoomId: rooms[0]?.id }),
+        artifacts: compactPayload({ sessionId, channelId: channel.id, activeRoomId: rooms[0]?.id, memberId: selfMember?.id }),
         result: {
             joined: true,
+            ...(selfMember
+                ? { member: { id: selfMember.id, handle: selfMember.handle, roleKey: selfMember.roleKey, status: selfMember.status } }
+                : {}),
             saved: options.saveSession === true,
             summary: buildJoinSummary({
                 channel,
@@ -1112,13 +1127,47 @@ export async function runChatv3Listen(options = {}) {
         },
     });
 }
+export async function runChatv3RoomMembers(options = {}) {
+    const sessionId = normalizeNonEmpty(options.session);
+    if (!sessionId)
+        throw new Error('Provide --session <id>.');
+    const limit = options.limit === undefined ? undefined : toInteger(options.limit, '--limit');
+    const requestedStatus = normalizeNonEmpty(options.status);
+    if (requestedStatus && !['active', 'left', 'removed', 'all'].includes(requestedStatus)) {
+        throw new Error('--status must be one of: active, left, removed, all.');
+    }
+    const status = requestedStatus === 'all' ? undefined : (requestedStatus ?? 'active');
+    const runtime = await loadRuntime(options, sessionId);
+    const room = resolveRoom(runtime, options.room);
+    const roomMembers = await fetchRoomMembers(runtime, room.id, { status, limit });
+    buildEnvelope({
+        options,
+        command: 'chatv3.room.members',
+        serverBaseUrl: runtime.record.serverBaseUrl,
+        input: compactPayload({ session: sessionId, room: options.room ?? room.slug, status: status ?? 'all', limit }),
+        artifacts: { sessionId, channelId: runtime.channel.id, roomId: room.id },
+        result: {
+            room: { id: room.id, slug: room.slug, title: room.title },
+            statusFilter: status ?? 'all',
+            members: roomMembers,
+            memberCount: roomMembers.length,
+        },
+    });
+}
 export async function runChatv3MemberList(options = {}) {
     const sessionId = normalizeNonEmpty(options.session);
     if (!sessionId)
         throw new Error('Provide --session <id>.');
+    if (normalizeNonEmpty(options.room)) {
+        await runChatv3RoomMembers(options);
+        return;
+    }
     const limit = options.limit === undefined ? undefined : toInteger(options.limit, '--limit');
     const runtime = await loadRuntime(options, sessionId);
-    const members = await runtime.client.listMembers(runtime.channel.id, { status: options.status, limit });
+    const members = await runtime.client.listMembers(runtime.channel.id, {
+        status: options.status === 'left' || options.status === 'all' ? undefined : options.status,
+        limit,
+    });
     buildEnvelope({
         options,
         command: 'chatv3.member.list',
@@ -1132,9 +1181,45 @@ export async function runChatv3MemberList(options = {}) {
         },
     });
 }
+async function fetchRoomMembers(runtime, roomId, opts = {}) {
+    const query = new URLSearchParams();
+    if (normalizeNonEmpty(opts.status))
+        query.set('status', String(opts.status));
+    if (opts.limit !== undefined && opts.limit > 0)
+        query.set('limit', String(opts.limit));
+    const qs = query.toString();
+    return runtime.client.http
+        .get(`/rooms/${roomId}/members${qs ? `?${qs}` : ''}`)
+        .catch(withRoomMembersSupportHint);
+}
+async function updateRoomMemberStatus(runtime, roomId, memberId, status) {
+    return runtime.client.http
+        .request('PATCH', `/rooms/${roomId}/members/${memberId}`, { status })
+        .catch(withRoomMembersSupportHint);
+}
 export async function runChatv3MemberRemove(options = {}) {
     const memberId = requireField(options.member, '--member');
     const { sessionId, runtime } = await loadRuntimeForChannelGuard(options);
+    if (normalizeNonEmpty(options.room)) {
+        const room = resolveRoom(runtime, options.room);
+        const membership = await updateRoomMemberStatus(runtime, room.id, memberId, 'removed');
+        const roomMembers = await fetchRoomMembers(runtime, room.id).catch(() => []);
+        buildEnvelope({
+            options,
+            command: 'chatv3.room.member.remove',
+            serverBaseUrl: runtime.record.serverBaseUrl,
+            input: compactPayload({ session: sessionId, channel: options.channel, member: memberId, room: options.room }),
+            artifacts: { sessionId, channelId: runtime.channel.id, roomId: room.id, memberId },
+            result: {
+                removedFromRoom: true,
+                room: { id: room.id, slug: room.slug, title: room.title },
+                membership,
+                members: roomMembers,
+                memberCount: roomMembers.length,
+            },
+        });
+        return;
+    }
     const beforeMembers = await runtime.client.listMembers(runtime.channel.id).catch(() => []);
     const target = beforeMembers.find((member) => member.id === memberId);
     if (target && target.channelId !== runtime.channel.id) {
@@ -1161,6 +1246,166 @@ export async function runChatv3MemberRemove(options = {}) {
         },
     });
 }
+export async function runChatv3MemberRestore(options = {}) {
+    const memberId = requireField(options.member, '--member');
+    const { sessionId, runtime } = await loadRuntimeForChannelGuard(options);
+    if (normalizeNonEmpty(options.room)) {
+        const room = resolveRoom(runtime, options.room);
+        const membership = await updateRoomMemberStatus(runtime, room.id, memberId, 'active');
+        const roomMembers = await fetchRoomMembers(runtime, room.id).catch(() => []);
+        buildEnvelope({
+            options,
+            command: 'chatv3.room.member.restore',
+            serverBaseUrl: runtime.record.serverBaseUrl,
+            input: compactPayload({ session: sessionId, channel: options.channel, member: memberId, room: options.room }),
+            artifacts: { sessionId, channelId: runtime.channel.id, roomId: room.id, memberId },
+            result: {
+                restoredToRoom: true,
+                room: { id: room.id, slug: room.slug, title: room.title },
+                membership,
+                members: roomMembers,
+                memberCount: roomMembers.length,
+            },
+        });
+        return;
+    }
+    const member = await runtime.client.updateMember(memberId, { status: 'active' });
+    if (member.channelId !== runtime.channel.id) {
+        throw new Error(`Server returned member ${member.id} from channel ${member.channelId}; expected ${runtime.channel.id}.`);
+    }
+    const members = await runtime.client.listMembers(runtime.channel.id).catch(() => [member]);
+    buildEnvelope({
+        options,
+        command: 'chatv3.member.restore',
+        serverBaseUrl: runtime.record.serverBaseUrl,
+        input: compactPayload({ session: sessionId, channel: options.channel, member: memberId }),
+        artifacts: { sessionId, channelId: runtime.channel.id, memberId },
+        result: {
+            restored: true,
+            member,
+            members,
+            memberCount: members.length,
+        },
+    });
+}
+export async function runChatv3RoomCreate(options = {}) {
+    const sessionId = normalizeNonEmpty(options.session);
+    if (!sessionId)
+        throw new Error('Provide --session <id>.');
+    const slug = requireField(options.slug, '--slug');
+    const title = normalizeNonEmpty(options.title) ?? slug;
+    const kind = normalizeNonEmpty(options.kind) ?? 'session';
+    if (kind !== 'session' && kind !== 'task')
+        throw new Error('--kind must be "session" or "task".');
+    const runtime = await loadRuntime(options, sessionId);
+    const room = await runtime.client.createRoom({
+        channel: {
+            id: runtime.channel.id,
+            tenantId: runtime.channel.tenantId,
+            spaceId: runtime.channel.spaceId,
+            encryptionMode: runtime.channel.encryptionMode,
+        },
+        slug,
+        title,
+        kind,
+        purpose: normalizeNonEmpty(options.purpose),
+    });
+    runtime.rooms = await runtime.client.listRooms(runtime.channel.id, { status: 'active' }).catch(() => [...runtime.rooms, room]);
+    if (runtime.channel.encryptionMode === 'server-encrypted') {
+        await refreshServerEpochKeys(runtime);
+    }
+    await persistRuntimeSnapshot(runtime, room.id);
+    const roomMembers = await fetchRoomMembers(runtime, room.id).catch(() => []);
+    buildEnvelope({
+        options,
+        command: 'chatv3.room.create',
+        serverBaseUrl: runtime.record.serverBaseUrl,
+        input: compactPayload({ session: sessionId, slug, title, kind, purpose: options.purpose }),
+        artifacts: { sessionId, channelId: runtime.channel.id, roomId: room.id },
+        result: {
+            room,
+            members: roomMembers,
+            memberCount: roomMembers.length,
+            note: 'New rooms start with only the creator as participant; others join explicitly or on first send.',
+        },
+    });
+}
+export async function runChatv3RoomList(options = {}) {
+    const sessionId = normalizeNonEmpty(options.session);
+    if (!sessionId)
+        throw new Error('Provide --session <id>.');
+    const runtime = await loadRuntime(options, sessionId);
+    buildEnvelope({
+        options,
+        command: 'chatv3.room.list',
+        serverBaseUrl: runtime.record.serverBaseUrl,
+        input: { session: sessionId },
+        artifacts: { sessionId, channelId: runtime.channel.id },
+        result: {
+            rooms: runtime.rooms.map((room) => compactPayload({
+                id: room.id,
+                slug: room.slug,
+                title: room.title,
+                kind: room.kind,
+                status: room.status,
+                currentEpoch: room.currentEpoch,
+                lastSeq: room.lastSeq,
+                createdBy: room.createdBy,
+            })),
+            roomCount: runtime.rooms.length,
+            activeRoomId: runtime.record.activeRoomId,
+        },
+    });
+}
+export async function runChatv3RoomJoin(options = {}) {
+    const sessionId = normalizeNonEmpty(options.session);
+    if (!sessionId)
+        throw new Error('Provide --session <id>.');
+    const runtime = await loadRuntime(options, sessionId);
+    const room = resolveRoom(runtime, options.room);
+    const membership = await runtime.client.http
+        .post(`/rooms/${room.id}/join`, {})
+        .catch(withRoomMembersSupportHint);
+    await persistRuntimeSnapshot(runtime, room.id);
+    const roomMembers = await fetchRoomMembers(runtime, room.id).catch(() => []);
+    buildEnvelope({
+        options,
+        command: 'chatv3.room.join',
+        serverBaseUrl: runtime.record.serverBaseUrl,
+        input: compactPayload({ session: sessionId, room: options.room ?? room.slug }),
+        artifacts: { sessionId, channelId: runtime.channel.id, roomId: room.id },
+        result: {
+            joined: membership.status === 'active',
+            membership,
+            members: roomMembers,
+            memberCount: roomMembers.length,
+        },
+    });
+}
+export async function runChatv3RoomLeave(options = {}) {
+    const sessionId = normalizeNonEmpty(options.session);
+    if (!sessionId)
+        throw new Error('Provide --session <id>.');
+    const runtime = await loadRuntime(options, sessionId);
+    const room = resolveRoom(runtime, options.room);
+    const membership = await runtime.client.http
+        .post(`/rooms/${room.id}/leave`, {})
+        .catch(withRoomMembersSupportHint);
+    buildEnvelope({
+        options,
+        command: 'chatv3.room.leave',
+        serverBaseUrl: runtime.record.serverBaseUrl,
+        input: compactPayload({ session: sessionId, room: options.room ?? room.slug }),
+        artifacts: { sessionId, channelId: runtime.channel.id, roomId: room.id },
+        result: {
+            left: membership.status === 'left',
+            membership,
+            note: membership.status === 'removed'
+                ? 'Membership stays "removed" (a room manager removed this member); re-join requires a manager restore.'
+                : 'Left the room roster; re-join any time with "room join" or by sending a message.',
+        },
+    });
+}
 export async function runChatv3PresenceList(options = {}) {
     const sessionId = normalizeNonEmpty(options.session);
     if (!sessionId)
@@ -1636,20 +1881,64 @@ export function makeChatv3Command(commandName = 'chat') {
         .option('--latest-seq <seq>', 'Explicit latest seq override; default room lastSeq')).action(async (options) => {
         await runChatv3RoomSummary(options);
     });
+    applyChatv3Options(room.command('create')
+        .description('Create a room in the session channel (creator becomes its first participant)')
+        .requiredOption('--session <id>', 'Local ChatV3 session id')
+        .requiredOption('--slug <slug>', 'Room slug (unique per channel)')
+        .option('--title <title>', 'Room title; defaults to the slug')
+        .option('--purpose <text>', 'Short room purpose')
+        .option('--kind <session|task>', 'Room kind', 'session')).action(async (options) => {
+        await runChatv3RoomCreate(options);
+    });
+    applyChatv3Options(room.command('list')
+        .description('List active rooms of the session channel')
+        .requiredOption('--session <id>', 'Local ChatV3 session id')).action(async (options) => {
+        await runChatv3RoomList(options);
+    });
+    applyChatv3Options(room.command('members')
+        .description('List the room-scoped participant roster (active participants by default)')
+        .requiredOption('--session <id>', 'Local ChatV3 session id')
+        .option('--room <slugOrId>', 'Room slug or id; default active/general room')
+        .option('--status <active|left|removed|all>', 'Participation status filter; default active, all returns every row')
+        .option('--limit <n>', 'Optional page limit')).action(async (options) => {
+        await runChatv3RoomMembers(options);
+    });
+    applyChatv3Options(room.command('join')
+        .description('Join a room roster (disjoin later with "room leave"); rejected after a room-level removal')
+        .requiredOption('--session <id>', 'Local ChatV3 session id')
+        .option('--room <slugOrId>', 'Room slug or id; default active/general room')).action(async (options) => {
+        await runChatv3RoomJoin(options);
+    });
+    applyChatv3Options(room.command('leave')
+        .description('Leave a room roster (disjoin); the channel membership stays intact')
+        .requiredOption('--session <id>', 'Local ChatV3 session id')
+        .option('--room <slugOrId>', 'Room slug or id; default active/general room')).action(async (options) => {
+        await runChatv3RoomLeave(options);
+    });
     const member = cmd.command('member').description('ChatV3 channel member roster');
     applyChatv3Options(member.command('list')
         .requiredOption('--session <id>', 'Local ChatV3 session id')
-        .option('--status <active|removed>', 'Member status filter')
-        .option('--limit <n>', 'Optional member page limit')).action(async (options) => {
+        .option('--status <active|removed>', 'Member status filter (with --room: active|left|removed|all, default active)')
+        .option('--limit <n>', 'Optional member page limit')
+        .option('--room <slugOrId>', 'List the room-scoped participant roster instead of the channel roster (active by default)')).action(async (options) => {
         await runChatv3MemberList(options);
     });
     applyChatv3Options(member.command('remove')
-        .description('Remove a member from a ChatV3 channel using an owner/operator session')
+        .description('Remove a member from a ChatV3 channel (owner/operator), or with --room kick them from one room (room creator or owner/operator)')
         .option('--session <id>', 'Local ChatV3 session id; required unless --channel matches exactly one local session')
         .option('--channel <idOrSlug>', 'Expected channel id/slug; required when --session is omitted and used as a guard when provided')
-        .requiredOption('--member <id>', 'Member id to remove')).action(async (options) => {
+        .requiredOption('--member <id>', 'Member id to remove')
+        .option('--room <slugOrId>', 'Kick from this room only (participation), keeping channel membership')).action(async (options) => {
         await runChatv3MemberRemove(options);
     });
+    applyChatv3Options(member.command('restore')
+        .description('Restore a removed member (channel-level, owner/operator), or with --room re-add them to one room')
+        .option('--session <id>', 'Local ChatV3 session id; required unless --channel matches exactly one local session')
+        .option('--channel <idOrSlug>', 'Expected channel id/slug; required when --session is omitted and used as a guard when provided')
+        .requiredOption('--member <id>', 'Member id to restore')
+        .option('--room <slugOrId>', 'Re-add to this room only (after a room-level kick)')).action(async (options) => {
+        await runChatv3MemberRestore(options);
+    });
     const presence = cmd.command('presence').description('ChatV3 room presence');
     applyChatv3Options(presence.command('list')
         .requiredOption('--session <id>', 'Local ChatV3 session id')

package/dist/commands/community-server.js

@@ -18,6 +18,15 @@ import { inspectCommunityNativeApplicationRecoveryStatus } from '../lib/communit
 import { inspectCommunityNativeDatabaseRecoveryStatus, restoreCommunityNativeDatabaseForUpdate, } from '../lib/community-native-database-recovery.js';
 import { inspectCommunityNativePostgres, removeCommunityNativePostgresContainerForReset, removeCommunityNativeManagedPostgres, } from '../lib/community-native-postgres.js';
 import { stopCommunityNativeCockpit } from '../lib/community-cockpit-lifecycle.js';
+function resolveReadyTimeoutMs(options) {
+    if (options.readyTimeoutMs === undefined)
+        return undefined;
+    const value = Number(options.readyTimeoutMs);
+    if (!Number.isSafeInteger(value) || value < 1_000 || value > 900_000) {
+        throw new Error('community_native_ready_timeout_invalid:expected_1000_to_900000_ms');
+    }
+    return value;
+}
 function nativePublicOrigin(state) {
     return state.server.host === '127.0.0.1'
         ? `http://127.0.0.1:${state.server.publicPort}`
@@ -431,6 +440,7 @@ async function runWithOperationJournal(params) {
             code: 'community_server_operation_failed',
             phase: 'operation',
             details: {
+                operationId: journal.record().id,
                 operation: params.operation,
                 journalPhase: journal.record().phase,
                 journalStep: journal.record().step,
@@ -640,6 +650,7 @@ export async function runCommunityServerSetup(options, dependencies = {}) {
                                 mode: resolveCommunityNativeLaunchMode(options),
                                 createPostgresSecret: options.createPostgresSecret,
                                 progress: options.progressSink,
+                                readyTimeoutMs: resolveReadyTimeoutMs(options),
                                 signal,
                             });
                             assertInstanceDirectoryIdentity(instanceIdentity);
@@ -770,6 +781,7 @@ export async function runCommunityServerStart(options, dependencies = {}) {
                 ...installSelection(options),
                 adoptSourceRoot: runtime.resolveNativeInstalledNpmSourceRoot(),
                 mode: resolveCommunityNativeLaunchMode(options),
+                readyTimeoutMs: resolveReadyTimeoutMs(options),
                 signal,
             }));
             writeResult({
@@ -843,6 +855,7 @@ export async function runCommunityServerRestart(options, dependencies = {}) {
                 return startCommunityNativeInstall({
                     ...installSelection(options),
                     mode: resolveCommunityNativeLaunchMode(options),
+                    readyTimeoutMs: resolveReadyTimeoutMs(options),
                     signal,
                 });
             });
@@ -1128,6 +1141,7 @@ export async function runCommunityServerUpdate(options, dependencies = {}) {
                     dataRoot: locked.paths.dataRoot,
                     mode: resolveCommunityNativeLaunchMode(options),
                     requireApplicationUpdate: true,
+                    readyTimeoutMs: resolveReadyTimeoutMs(options),
                     signal,
                 });
             });
@@ -1339,6 +1353,7 @@ export async function runCommunityServerRollbackApplication(options, dependencie
                 updateId: options.updateId,
                 sourceRoot: options.sourceRoot,
                 mode: resolveCommunityNativeLaunchMode(options),
+                readyTimeoutMs: resolveReadyTimeoutMs(options),
                 signal,
             });
         });
@@ -1965,18 +1980,21 @@ export function makeCommunityServerCommand(identity = {}) {
         .option('--port <number>', 'Host port', '5900')
         .option('--foreground', 'Keep the native server attached to this terminal')
         .option('--detach', 'Start the native server in the background (default)')
+        .option('--ready-timeout-ms <milliseconds>', 'Native Server readiness budget from 1000 to 900000 ms; default 120000')
         .option('--preview', 'Validate and print the setup contract without mutation')
         .option('--apply', 'Apply the selected setup contract')
         .action((options) => runCommunityServerSetup(options, dependencies));
     common(command.command('start').alias('up').description('Start the installed native npm/source host or OCI stack'))
         .option('--foreground', 'Keep the native server attached to this terminal')
         .option('--detach', 'Start the native server in the background (default)')
+        .option('--ready-timeout-ms <milliseconds>', 'Native Server readiness budget from 1000 to 900000 ms; default 120000')
         .action((options) => runCommunityServerStart(options, dependencies));
     common(command.command('stop').alias('down').description('Stop the server without deleting data'))
         .action((options) => runCommunityServerStop(options, dependencies));
     common(command.command('restart').description('Restart the installed server'))
         .option('--foreground', 'Keep the restarted native server attached to this terminal')
         .option('--detach', 'Restart the native server in the background (default)')
+        .option('--ready-timeout-ms <milliseconds>', 'Native Server readiness budget from 1000 to 900000 ms; default 120000')
         .action((options) => runCommunityServerRestart(options, dependencies));
     common(command.command('status').description('Show install and runtime status')).action(runCommunityServerStatus);
     common(command.command('health').description('Check the installed server health without mutation')).action(runCommunityServerHealth);
@@ -2000,6 +2018,7 @@ export function makeCommunityServerCommand(identity = {}) {
         .option('--source-root <path>', 'Optional Community checkout for a native update; defaults to the installed official npm runtime')
         .option('--foreground', 'Keep the updated native server attached to this terminal')
         .option('--detach', 'Start the updated native server in the background (default)')
+        .option('--ready-timeout-ms <milliseconds>', 'Native Server readiness budget from 1000 to 900000 ms; default 120000')
         .action((options) => runCommunityServerUpdate(options, dependencies));
     common(command.command('recover').description('Recover one exact failed or unhealthy update from its verified backup'))
         .requiredOption('--update-id <id>', 'Exact update ID recorded by the failed or unhealthy update')
@@ -2021,6 +2040,7 @@ export function makeCommunityServerCommand(identity = {}) {
         .requiredOption('--source-root <path>', 'Exact prior public release checkout; the CLI never downloads or changes it')
         .option('--foreground', 'Keep the rolled-back native server attached to this terminal')
         .option('--detach', 'Start the rolled-back native server in the background (default)')
+        .option('--ready-timeout-ms <milliseconds>', 'Native Server readiness budget from 1000 to 900000 ms; default 120000')
         .action((options, child) => runCommunityServerRollbackApplication(mergeCommunityCommandOptions(options, child), dependencies));
     common(command.command('backup').description('Create and verify a custom-format PostgreSQL backup plus receipt'))
         .action((options) => runCommunityServerBackup(options, dependencies));