@bbigbang/cli 0.1.0

package/dist/commands/messageCommands.js

@@ -0,0 +1,241 @@
+import { randomUUID } from 'node:crypto';
+import { Option } from 'commander';
+import { AGENT_COMMAND_ERROR_CODES, AgentCommandError, MUTATION_HINTS, appendCommonBody, createRuntime, formatMessageHeld, isHeldResponse, isMessageNotResolved, isSuppressedResponse, parseNonNegativeInteger, parsePositiveInteger, readRequiredStdin, repeatOption, requireString, responseError, withHint, writeOutput, writeReceipt } from '../cliSupport.js';
+export function registerMessageCommands(program, options) {
+    const message = program.command('message').description('Message operations');
+    message.command('send')
+        .description('Send a message from stdin')
+        .option('--target <target>', 'Target: #channel, dm:@name, or thread target. Defaults to the current conversation when omitted.')
+        .addOption(new Option('--channel <target>', 'Alias for --target.').hideHelp())
+        .option('--kind <kind>', 'Message kind: progress or final', 'progress')
+        .option('--peer-delivery <mode>', 'Shared-surface peer delivery: silent, batch, or immediate')
+        .option('--attachment-id <id>', 'Attachment id to include; repeatable', repeatOption)
+        .option('--panel-id <id>', 'Panel id to include; repeatable', repeatOption)
+        .option('--panel-preview-id <id>', 'Ephemeral panel preview id to include; repeatable', repeatOption)
+        .option('--tool-id <id>', 'Tool id to include; repeatable', repeatOption)
+        .option('--slash-command-failed <reason>', 'Allow a final reply for /panel, /panel:plan, or /tool when the requested artifact cannot be created; requires a clear reason')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const target = (typeof opts.target === 'string' ? opts.target.trim() : '')
+            || (typeof opts.channel === 'string' ? opts.channel.trim() : '');
+        const peerDelivery = typeof opts.peerDelivery === 'string' ? opts.peerDelivery.trim() : '';
+        const slashCommandFailureReason = typeof opts.slashCommandFailed === 'string'
+            ? opts.slashCommandFailed.trim()
+            : '';
+        const content = await readRequiredStdin(runtime.io.stdin, 'message content');
+        const kind = opts.kind === 'final' ? 'final' : 'progress';
+        if (slashCommandFailureReason && kind !== 'final') {
+            throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.INVALID_ARG, '--slash-command-failed is only supported with --kind final.');
+        }
+        if (opts.slashCommandFailed !== undefined && !slashCommandFailureReason) {
+            throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.INVALID_ARG, '--slash-command-failed requires a non-empty reason.');
+        }
+        const clientMessageId = resolveMessageSendClientMessageId(runtime, {
+            target,
+            content: content.trim(),
+            kind,
+            peerDelivery,
+            attachmentIds: opts.attachmentId ?? [],
+            panelIds: opts.panelId ?? [],
+            panelPreviewIds: opts.panelPreviewId ?? [],
+            toolIds: opts.toolId ?? [],
+        });
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/send`, appendCommonBody(runtime, {
+            ...(target ? { target } : {}),
+            content,
+            kind,
+            clientMessageId,
+            ...(peerDelivery ? { peer_delivery: peerDelivery } : {}),
+            ...(opts.attachmentId?.length ? { attachmentIds: opts.attachmentId } : {}),
+            ...(opts.panelId?.length ? { panelIds: opts.panelId } : {}),
+            ...(opts.panelPreviewId?.length ? { panelPreviewIds: opts.panelPreviewId } : {}),
+            ...(opts.toolId?.length ? { toolIds: opts.toolId } : {}),
+            ...(slashCommandFailureReason ? { slashCommandFailureReason } : {}),
+        }));
+        if (!response.ok)
+            throw responseError(response, 'send failed');
+        if (isSuppressedResponse(response.data)) {
+            const data = response.data;
+            const message = typeof data.message === 'string' && data.message.trim()
+                ? data.message.trim()
+                : 'Message suppressed by platform policy.';
+            writeOutput(runtime, message, response.data);
+            return;
+        }
+        if (isHeldResponse(response.data)) {
+            writeOutput(runtime, formatMessageHeld(target || 'current conversation', response.data), response.data);
+            return;
+        }
+        const data = response.data;
+        const messageId = typeof data?.messageId === 'string' ? data.messageId : '';
+        if (!messageId) {
+            throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.MISSING_MESSAGE_ID, 'send returned success without a messageId; nothing was confirmed posted.');
+        }
+        const sentTarget = String(data.target ?? (target || 'current conversation'));
+        writeOutput(runtime, withHint(`Message sent to ${sentTarget}. Message ID: ${messageId}`, MUTATION_HINTS.messageSend), response.data);
+        writeReceipt(runtime, {
+            op: 'message.send',
+            ok: true,
+            kind,
+            messageId,
+            target: sentTarget,
+            ...(runtime.runId ? { runId: runtime.runId } : {}),
+            ...(runtime.context.conversationId ? { conversationId: runtime.context.conversationId } : {}),
+        });
+    });
+    message.command('check')
+        .description('Check for pending messages')
+        .option('--channel <target>', 'Optional channel/DM target filter')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const params = new URLSearchParams();
+        if (opts.channel)
+            params.set('channel', opts.channel);
+        if (runtime.context.conversationId)
+            params.set('conversationId', runtime.context.conversationId);
+        if (runtime.runId)
+            params.set('runId', runtime.runId);
+        if (runtime.turnId)
+            params.set('turnId', runtime.turnId);
+        if (runtime.traceId)
+            params.set('traceId', runtime.traceId);
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/receive?${params.toString()}`, undefined, { retry: 'never' });
+        if (!response.ok)
+            throw responseError(response, 'receive failed');
+        const data = response.data;
+        const count = data?.messages?.length ?? 0;
+        writeOutput(runtime, count > 0 ? `Received ${count} message(s).` : 'No new messages.', response.data);
+    });
+    message.command('read')
+        .description('Read message history')
+        .requiredOption('--channel <target>', 'Channel, DM, or thread target')
+        .option('--limit <n>', 'Max messages to return')
+        .option('--around <idOrSeq>', 'Center around message id prefix or seq')
+        .option('--before <seq>', 'Read before seq')
+        .option('--after <seq>', 'Read after seq')
+        .option('--include-root', 'Include thread root when reading a thread')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const params = new URLSearchParams();
+        params.set('channel', requireString(opts.channel, '--channel'));
+        const limit = parsePositiveInteger('limit', opts.limit);
+        if (limit !== undefined)
+            params.set('limit', String(Math.min(limit, 100)));
+        if (opts.around !== undefined)
+            params.set('around', String(opts.around));
+        const before = parseNonNegativeInteger('before', opts.before);
+        const after = parseNonNegativeInteger('after', opts.after);
+        if (before !== undefined)
+            params.set('before', String(before));
+        if (after !== undefined)
+            params.set('after', String(after));
+        if (opts.includeRoot)
+            params.set('include_root', 'true');
+        if (runtime.context.conversationId)
+            params.set('conversationId', runtime.context.conversationId);
+        if (runtime.runId)
+            params.set('runId', runtime.runId);
+        if (runtime.turnId)
+            params.set('turnId', runtime.turnId);
+        if (runtime.traceId)
+            params.set('traceId', runtime.traceId);
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/history?${params.toString()}`);
+        if (!response.ok)
+            throw responseError(response, 'history fetch failed');
+        const data = response.data;
+        writeOutput(runtime, `Read ${data?.messages?.length ?? 0} message(s).`, response.data);
+    });
+    message.command('search')
+        .description('Search visible messages')
+        .requiredOption('--query <q>', 'Search query')
+        .option('--channel <target>', 'Optional channel, DM, or thread target')
+        .option('--limit <n>', 'Max results')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const query = requireString(opts.query, '--query');
+        const params = new URLSearchParams();
+        params.set('q', query);
+        const limit = parsePositiveInteger('limit', opts.limit);
+        if (limit !== undefined)
+            params.set('limit', String(Math.min(limit, 20)));
+        if (opts.channel)
+            params.set('channel', String(opts.channel));
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/search?${params.toString()}`);
+        if (!response.ok)
+            throw responseError(response, 'message search failed');
+        const data = response.data;
+        writeOutput(runtime, `Found ${data?.results?.length ?? 0} message(s).`, response.data);
+    });
+    message.command('resolve')
+        .description('Resolve one message by id or prefix inside a target')
+        .requiredOption('--channel <target>', 'Channel, DM, or thread target from search/read output')
+        .requiredOption('--message-id <id>', 'Message id or unique prefix')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const channel = requireString(opts.channel, '--channel');
+        const messageId = requireString(opts.messageId, '--message-id');
+        const params = new URLSearchParams();
+        params.set('channel', channel);
+        params.set('around', messageId);
+        params.set('limit', '1');
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/history?${params.toString()}`);
+        if (!response.ok) {
+            if (isMessageNotResolved(response)) {
+                throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.MESSAGE_NOT_RESOLVED, `No message matching ${messageId} was returned for ${channel}.`, { status: response.status, suggestedNextAction: 'Run bigbang message search again and pass the returned target and msg id to resolve.' });
+            }
+            throw responseError(response, 'message resolve failed');
+        }
+        const data = response.data;
+        const resolved = Array.isArray(data?.messages)
+            ? data.messages.find((item) => typeof item?.id === 'string' && item.id.startsWith(messageId))
+            : null;
+        if (!resolved) {
+            throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.MESSAGE_NOT_RESOLVED, `No message matching ${messageId} was returned for ${channel}.`, { suggestedNextAction: 'Run bigbang message search again and pass the returned target and msg id to resolve.' });
+        }
+        const outputData = response.data && typeof response.data === 'object'
+            ? { ...response.data, resolved }
+            : { resolved };
+        writeOutput(runtime, `Resolved message ${String(resolved.id)} in ${channel}.`, outputData);
+    });
+    message.command('react')
+        .description('Add or remove a reaction on a message')
+        .option('--message-id <id>', 'Message id')
+        .option('--emoji <emoji>', 'Emoji to react with')
+        .option('--remove', 'Remove the reaction instead of adding it')
+        .option('--channel <target>', 'Optional channel, DM, or thread target hint; validated against the message channel')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const messageId = requireString(opts.messageId, '--message-id');
+        const emoji = requireString(opts.emoji, '--emoji');
+        const channel = typeof opts.channel === 'string' ? opts.channel.trim() : '';
+        const agentId = encodeURIComponent(runtime.context.agentId);
+        const encodedMessageId = encodeURIComponent(messageId);
+        const encodedEmoji = encodeURIComponent(emoji);
+        if (opts.remove) {
+            const params = new URLSearchParams();
+            if (channel)
+                params.set('channel', channel);
+            const qs = params.toString();
+            const response = await runtime.client.request('DELETE', `/api/internal/agent/${agentId}/messages/${encodedMessageId}/reactions/${encodedEmoji}${qs ? `?${qs}` : ''}`);
+            if (!response.ok)
+                throw responseError(response, 'remove reaction failed');
+            writeOutput(runtime, `Removed ${emoji} reaction from ${messageId}.`, response.data);
+            return;
+        }
+        const body = { emoji };
+        if (channel)
+            body.channel = channel;
+        const response = await runtime.client.request('POST', `/api/internal/agent/${agentId}/messages/${encodedMessageId}/reactions`, body);
+        if (!response.ok)
+            throw responseError(response, 'add reaction failed');
+        writeOutput(runtime, `Reacted with ${emoji} on ${messageId}.`, response.data);
+    });
+}
+function resolveMessageSendClientMessageId(runtime, params) {
+    const override = runtime.env.BIGBANG_MESSAGE_SEND_OPERATION_ID?.trim()
+        || runtime.env.BIGBANG_MESSAGE_SEND_OPERATION_ID?.trim();
+    if (override)
+        return override;
+    void params;
+    return `client-${randomUUID()}-bigbang-send`;
+}

package/dist/commands/panelCommands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import type { BuildBigbangProgramOptions } from '../cliSupport.js';
+export declare function registerPanelCommands(program: Command, options: BuildBigbangProgramOptions): void;

package/dist/commands/panelCommands.js

@@ -0,0 +1,218 @@
+import { readFileSync } from 'node:fs';
+import { AGENT_COMMAND_ERROR_CODES, AgentCommandError, MUTATION_HINTS, appendCommonBody, createRuntime, formatPanelVersionConflict, isVersionConflict, normalizePanelPayload, parseJsonStdinOrThrow, parseNonNegativeInteger, parsePositiveInteger, readRequiredStdin, repeatOption, requireString, responseError, summarizePanelCollaborators, summarizePanelComponents, summarizePanelState, withHint, writeJson, writeOutput } from '../cliSupport.js';
+export function registerPanelCommands(program, options) {
+    const panel = program.command('panel').description('Panel operations');
+    panel.command('create')
+        .description('Create a new panel from stdin JSON')
+        .action(async () => {
+        const runtime = createRuntime(program, options);
+        const payload = normalizePanelPayload(await parseJsonStdinOrThrow(runtime, 'panel create JSON payload'), 'panel create');
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels`, appendCommonBody(runtime, payload));
+        if (!response.ok)
+            throw responseError(response, 'panel create failed');
+        const data = response.data;
+        writeOutput(runtime, withHint(`Panel created. panel_id=${String(data.panel_id ?? '')} version=${String(data.version ?? '')}`, MUTATION_HINTS.panelInspect), response.data);
+    });
+    panel.command('upsert')
+        .description('Create or update a stable-handle panel from stdin JSON')
+        .action(async () => {
+        const runtime = createRuntime(program, options);
+        const payload = normalizePanelPayload(await parseJsonStdinOrThrow(runtime, 'panel upsert JSON payload'), 'panel upsert');
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/upsert`, appendCommonBody(runtime, payload));
+        if (!response.ok) {
+            if (isVersionConflict(response)) {
+                writeOutput(runtime, formatPanelVersionConflict(response.data), response.data);
+                return;
+            }
+            throw responseError(response, 'panel upsert failed');
+        }
+        const data = response.data;
+        writeOutput(runtime, withHint(`Panel upserted. panel_id=${String(data.panel_id ?? '')} version=${String(data.version ?? '')}`, MUTATION_HINTS.panelInspect), response.data);
+    });
+    panel.command('patch')
+        .description('Patch a panel from stdin JSON')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const payload = normalizePanelPayload(await parseJsonStdinOrThrow(runtime, 'panel patch JSON payload'), 'panel patch');
+        const response = await runtime.client.request('PATCH', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}`, appendCommonBody(runtime, payload));
+        if (!response.ok) {
+            if (isVersionConflict(response)) {
+                writeOutput(runtime, formatPanelVersionConflict(response.data), response.data);
+                return;
+            }
+            throw responseError(response, 'panel patch failed');
+        }
+        const data = response.data;
+        writeOutput(runtime, `Panel patched. panel_id=${String(data.panel_id ?? panelId)} version=${String(data.version ?? '')}`, response.data);
+    });
+    panel.command('read-rows')
+        .description('Read panel rows')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .option('--conversation-id <id>', 'Panel owner conversation id')
+        .option('--row-index <n>', 'Specific row index to read; repeat for multiple rows', repeatOption)
+        .option('--limit <n>', 'Maximum rows')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const body = {};
+        if (opts.conversationId)
+            body.conversationId = opts.conversationId;
+        else if (runtime.context.conversationId)
+            body.conversationId = runtime.context.conversationId;
+        const rowIndices = Array.isArray(opts.rowIndex)
+            ? opts.rowIndex.map((value) => {
+                const parsed = parseNonNegativeInteger('row-index', value);
+                if (parsed === undefined) {
+                    throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.INVALID_ARG, '--row-index is required.');
+                }
+                return parsed;
+            })
+            : undefined;
+        if (rowIndices !== undefined && rowIndices.length > 0)
+            body.row_indices = rowIndices;
+        const limit = parsePositiveInteger('limit', opts.limit);
+        if (limit !== undefined)
+            body.limit = limit;
+        if (opts.cursor)
+            body.cursor = opts.cursor;
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}/rows/read`, body);
+        if (!response.ok)
+            throw responseError(response, 'read panel rows failed');
+        const data = response.data;
+        writeOutput(runtime, `Read ${data?.rows?.length ?? 0} row(s).`, response.data);
+    });
+    panel.command('read-events')
+        .description('Read panel semantic events')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .option('--conversation-id <id>', 'Panel owner conversation id')
+        .option('--limit <n>', 'Maximum events')
+        .option('--after-event-id <id>', 'Only return events after this event id')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const body = {};
+        if (opts.conversationId)
+            body.conversationId = opts.conversationId;
+        else if (runtime.context.conversationId)
+            body.conversationId = runtime.context.conversationId;
+        const limit = parsePositiveInteger('limit', opts.limit);
+        if (limit !== undefined)
+            body.limit = limit;
+        const afterEventId = parseNonNegativeInteger('after-event-id', opts.afterEventId);
+        if (afterEventId !== undefined)
+            body.after_event_id = afterEventId;
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}/events/read`, body);
+        if (!response.ok)
+            throw responseError(response, 'read panel events failed');
+        const data = response.data;
+        writeOutput(runtime, `Read ${data?.events?.length ?? 0} event(s).`, response.data);
+    });
+    panel.command('state')
+        .description('Read current saved panel state for this agent surface')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}/state`);
+        if (!response.ok)
+            throw responseError(response, 'read panel state failed');
+        writeOutput(runtime, summarizePanelState(response.data), response.data);
+    });
+    const createPanelPreview = async (opts) => {
+        const runtime = createRuntime(program, options);
+        const raw = typeof opts.specPath === 'string' && opts.specPath.trim()
+            ? readFileSync(opts.specPath.trim(), 'utf8')
+            : await readRequiredStdin(runtime.io.stdin, 'panel preview JSON payload');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.INVALID_JSON_STDIN, `Invalid panel preview JSON: ${error?.message ?? String(error)}`);
+        }
+        const payload = normalizePanelPayload(parsed, 'panel preview');
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/preview`, appendCommonBody(runtime, payload));
+        if (!response.ok)
+            throw responseError(response, 'panel preview failed');
+        const data = response.data;
+        const previewId = String(data.panel_preview_id ?? data.previewId ?? '');
+        writeOutput(runtime, withHint(`Panel preview created. panel_preview_id=${previewId}`, `Next: bigbang message send --kind final --panel-preview-id ${previewId}`), response.data);
+    };
+    const panelPreview = panel.command('preview')
+        .description('Panel preview operations')
+        .option('--spec-path <path>', 'Alias for preview create: read preview spec JSON from this file instead of stdin')
+        .action(createPanelPreview);
+    panelPreview.command('create')
+        .description('Create an ephemeral read-only panel preview from stdin JSON or --spec-path')
+        .option('--spec-path <path>', 'Read preview spec JSON from this file instead of stdin')
+        .action(createPanelPreview);
+    panelPreview.command('show')
+        .description('Show an ephemeral panel preview spec')
+        .requiredOption('--preview-id <id>', 'Panel preview id')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const previewId = requireString(opts.previewId, '--preview-id');
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/preview/${encodeURIComponent(previewId)}`);
+        if (!response.ok)
+            throw responseError(response, 'panel preview show failed');
+        writeJson(runtime, response.data);
+    });
+    const panelCollaborators = panel.command('collaborators').description('Panel collaborator operations');
+    panelCollaborators.command('list')
+        .description('List panel owner/collaborator agents')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}/collaborators`);
+        if (!response.ok)
+            throw responseError(response, 'list panel collaborators failed');
+        writeOutput(runtime, summarizePanelCollaborators(response.data), response.data);
+    });
+    panelCollaborators.command('add')
+        .description('Owner-only: add a collaborator agent to a panel')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .option('--agent-id <id>', 'Collaborator agent id')
+        .option('--agent-name <name>', 'Collaborator agent display name')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const collaboratorAgentId = typeof opts.agentId === 'string' ? opts.agentId.trim() : '';
+        const collaboratorName = typeof opts.agentName === 'string' ? opts.agentName.trim() : '';
+        if (!collaboratorAgentId && !collaboratorName) {
+            throw new AgentCommandError(AGENT_COMMAND_ERROR_CODES.INVALID_ARG, 'Provide --agent-id or --agent-name.');
+        }
+        const response = await runtime.client.request('POST', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}/collaborators`, {
+            ...(collaboratorAgentId ? { collaboratorAgentId } : {}),
+            ...(collaboratorName ? { collaboratorName } : {}),
+        });
+        if (!response.ok)
+            throw responseError(response, 'add panel collaborator failed');
+        writeOutput(runtime, summarizePanelCollaborators(response.data), response.data);
+    });
+    panelCollaborators.command('remove')
+        .description('Owner-only: remove a non-owner collaborator agent from a panel')
+        .requiredOption('--panel-id <id>', 'Panel id')
+        .requiredOption('--agent-id <id>', 'Collaborator agent id')
+        .action(async (opts) => {
+        const runtime = createRuntime(program, options);
+        const panelId = requireString(opts.panelId, '--panel-id');
+        const collaboratorAgentId = requireString(opts.agentId, '--agent-id');
+        const response = await runtime.client.request('DELETE', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/panels/${encodeURIComponent(panelId)}/collaborators/${encodeURIComponent(collaboratorAgentId)}`);
+        if (!response.ok)
+            throw responseError(response, 'remove panel collaborator failed');
+        writeOutput(runtime, summarizePanelCollaborators(response.data), response.data);
+    });
+    panel.command('components')
+        .description('List available panel UI component contracts')
+        .action(async () => {
+        const runtime = createRuntime(program, options);
+        const response = await runtime.client.request('GET', `/api/internal/agent/${encodeURIComponent(runtime.context.agentId)}/ui-components`);
+        if (!response.ok)
+            throw responseError(response, 'list panel components failed');
+        writeOutput(runtime, summarizePanelComponents(response.data), response.data);
+    });
+}

package/dist/commands/reminderCommands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import type { BuildBigbangProgramOptions } from '../cliSupport.js';
+export declare function registerReminderCommands(program: Command, options: BuildBigbangProgramOptions): void;