@bbigbang/core 0.1.0

package/dist/web/actionCards.js

@@ -0,0 +1,469 @@
+import { randomUUID } from 'node:crypto';
+import { allocateNextChannelMessageSeq } from './channelMessageSequences.js';
+import { insertPanel } from './panels.js';
+export const ACTION_CARD_REASON_MAX_LENGTH = 500;
+export class ActionCardError extends Error {
+    statusCode;
+    errorCode;
+    constructor(statusCode, message, errorCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.errorCode = errorCode;
+    }
+}
+function parseJsonObject(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeStatus(value) {
+    return value === 'confirmed'
+        || value === 'cancelled'
+        || value === 'expired'
+        || value === 'failed'
+        ? value
+        : 'pending';
+}
+function normalizeActionType(value) {
+    if (value === 'channel:create' || value === 'agent:create' || value === 'channel:add_member')
+        return value;
+    throw new ActionCardError(400, `Unsupported action type: ${value}`, 'UNSUPPORTED_ACTION_TYPE');
+}
+function rowToActionCard(row) {
+    return {
+        id: row.id,
+        actionType: normalizeActionType(row.actionType),
+        payload: parseJsonObject(row.payloadJson) ?? {},
+        originConversationId: row.originConversationId,
+        originChannelId: row.originChannelId,
+        originThreadRootId: row.originThreadRootId,
+        proposerAgentId: row.proposerAgentId,
+        runId: row.runId,
+        turnId: row.turnId,
+        traceId: row.traceId,
+        reason: row.reason,
+        status: normalizeStatus(row.status),
+        expiresAt: row.expiresAt,
+        confirmedBy: row.confirmedBy,
+        result: parseJsonObject(row.resultJson),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        confirmedAt: row.confirmedAt,
+        cancelledAt: row.cancelledAt,
+        failedAt: row.failedAt,
+    };
+}
+export function getActionCardById(db, id) {
+    const row = db.prepare(`SELECT id, action_type as actionType, payload_json as payloadJson,
+            origin_conversation_id as originConversationId,
+            origin_channel_id as originChannelId,
+            origin_thread_root_id as originThreadRootId,
+            proposer_agent_id as proposerAgentId,
+            run_id as runId,
+            turn_id as turnId,
+            trace_id as traceId,
+            reason,
+            status, expires_at as expiresAt,
+            confirmed_by as confirmedBy,
+            result_json as resultJson,
+            created_at as createdAt,
+            updated_at as updatedAt,
+            confirmed_at as confirmedAt,
+            cancelled_at as cancelledAt,
+            failed_at as failedAt
+       FROM action_cards
+      WHERE id = ?
+      LIMIT 1`).get(id);
+    return row ? rowToActionCard(row) : null;
+}
+function requireRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new ActionCardError(400, `${label} must be a JSON object`, 'INVALID_ACTION_PAYLOAD');
+    }
+    return value;
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeReason(value) {
+    const normalized = value?.trim() ?? '';
+    if (!normalized)
+        return null;
+    return normalized.slice(0, ACTION_CARD_REASON_MAX_LENGTH);
+}
+function requireStringField(payload, field) {
+    const value = optionalString(payload[field]);
+    if (!value)
+        throw new ActionCardError(400, `${field} is required`, 'INVALID_ACTION_PAYLOAD');
+    return value;
+}
+function normalizeStringArray(value, field) {
+    if (value == null)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new ActionCardError(400, `${field} must be an array`, 'INVALID_ACTION_PAYLOAD');
+    const normalized = value
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter(Boolean);
+    return normalized.length ? normalized : undefined;
+}
+function normalizeChannelCreatePayload(payload) {
+    return {
+        name: requireStringField(payload, 'name'),
+        ...(optionalString(payload.workspacePath) ? { workspacePath: optionalString(payload.workspacePath) } : {}),
+        ...(optionalString(payload.description) ? { description: optionalString(payload.description) } : {}),
+        ...(normalizeStringArray(payload.agentIds, 'agentIds') ? { agentIds: normalizeStringArray(payload.agentIds, 'agentIds') } : {}),
+        ...(payload.collaborationMode === 'mention_only' ? { collaborationMode: 'mention_only' } : {}),
+    };
+}
+function normalizeAgentCreatePayload(payload) {
+    const rawAgentType = optionalString(payload.agentType);
+    if (rawAgentType
+        && rawAgentType !== 'claude_acp'
+        && rawAgentType !== 'claude_sdk'
+        && rawAgentType !== 'codex_acp'
+        && rawAgentType !== 'codex_app_server') {
+        throw new ActionCardError(400, `Unsupported agentType: ${rawAgentType}`, 'INVALID_ACTION_PAYLOAD');
+    }
+    const agentType = rawAgentType;
+    return {
+        name: requireStringField(payload, 'name'),
+        ...(agentType ? { agentType } : {}),
+        ...(optionalString(payload.model) ? { model: optionalString(payload.model) } : {}),
+        ...(optionalString(payload.reasoningEffort) ? { reasoningEffort: optionalString(payload.reasoningEffort) } : {}),
+        ...(optionalString(payload.channelId) ? { channelId: optionalString(payload.channelId) } : {}),
+        ...(optionalString(payload.systemPrompt) ? { systemPrompt: optionalString(payload.systemPrompt) } : {}),
+        ...(optionalString(payload.description) ? { description: optionalString(payload.description) } : {}),
+        ...(optionalString(payload.nodeId) ? { nodeId: optionalString(payload.nodeId) } : {}),
+        ...(optionalString(payload.workspacePath) ? { workspacePath: optionalString(payload.workspacePath) } : {}),
+        ...(optionalString(payload.projectPath) ? { projectPath: optionalString(payload.projectPath) } : {}),
+        ...(normalizeStringArray(payload.skillRoots, 'skillRoots') ? { skillRoots: normalizeStringArray(payload.skillRoots, 'skillRoots') } : {}),
+    };
+}
+function normalizeAddMemberPayload(payload) {
+    return {
+        channelId: requireStringField(payload, 'channelId'),
+        agentId: requireStringField(payload, 'agentId'),
+    };
+}
+function normalizeActionPayload(actionType, payload) {
+    switch (actionType) {
+        case 'channel:create':
+            return normalizeChannelCreatePayload(payload);
+        case 'agent:create':
+            return normalizeAgentCreatePayload(payload);
+        case 'channel:add_member':
+            return normalizeAddMemberPayload(payload);
+    }
+}
+function summarizeAction(actionType, payload) {
+    if (actionType === 'channel:create')
+        return `Create channel "${String(payload.name)}"`;
+    if (actionType === 'agent:create')
+        return `Create agent "${String(payload.name)}"`;
+    return `Add agent ${String(payload.agentId)} to channel ${String(payload.channelId)}`;
+}
+function toPublicActionCard(card) {
+    return {
+        id: card.id,
+        actionCardId: card.id,
+        action_card_id: card.id,
+        actionType: card.actionType,
+        action_type: card.actionType,
+        payload: card.payload,
+        originConversationId: card.originConversationId,
+        origin_conversation_id: card.originConversationId,
+        originChannelId: card.originChannelId,
+        origin_channel_id: card.originChannelId,
+        originThreadRootId: card.originThreadRootId,
+        origin_thread_root_id: card.originThreadRootId,
+        proposerAgentId: card.proposerAgentId,
+        proposer_agent_id: card.proposerAgentId,
+        runId: card.runId,
+        run_id: card.runId,
+        turnId: card.turnId,
+        turn_id: card.turnId,
+        traceId: card.traceId,
+        trace_id: card.traceId,
+        reason: card.reason,
+        status: card.status,
+        expiresAt: card.expiresAt,
+        expires_at: card.expiresAt,
+        confirmedBy: card.confirmedBy,
+        confirmed_by: card.confirmedBy,
+        result: card.result,
+        createdAt: card.createdAt,
+        created_at: card.createdAt,
+        updatedAt: card.updatedAt,
+        updated_at: card.updatedAt,
+    };
+}
+function insertActionCardPanel(db, card) {
+    const panelId = `action-card-${card.id}`;
+    try {
+        return insertPanel(db, {
+            id: panelId,
+            agentId: card.proposerAgentId,
+            conversationId: card.originConversationId,
+            handle: panelId,
+            scopeType: card.originChannelId
+                ? (card.originThreadRootId ? 'thread' : 'channel')
+                : 'direct',
+            scopeId: card.originChannelId,
+            component: 'KeyValuePanel',
+            props: {
+                title: 'Action confirmation',
+                summary: summarizeAction(card.actionType, card.payload),
+                actionCardId: card.id,
+                actionType: card.actionType,
+                status: card.status,
+                expiresAt: new Date(card.expiresAt).toISOString(),
+                reason: card.reason,
+                runId: card.runId,
+                turnId: card.turnId,
+                traceId: card.traceId,
+                payload: card.payload,
+                confirmEndpoint: `/api/action-cards/${card.id}/confirm`,
+                cancelEndpoint: `/api/action-cards/${card.id}/cancel`,
+            },
+            actions: [
+                { id: 'confirm', label: 'Confirm', variant: 'primary', mode: 'platform_exec' },
+                { id: 'cancel', label: 'Cancel', variant: 'secondary', mode: 'platform_exec' },
+            ],
+            rowCount: 0,
+            status: 'idle',
+            createdByRunId: card.runId,
+            createdAt: card.createdAt,
+            updatedAt: card.updatedAt,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export function createActionCard(db, params) {
+    const actionType = normalizeActionType(params.actionType);
+    const rawPayload = requireRecord(params.payload, 'payload');
+    const payload = normalizeActionPayload(actionType, rawPayload);
+    const conversation = params.conversationManager.getConversation(params.originConversationId);
+    if (!conversation || conversation.agentId !== params.proposerAgentId) {
+        throw new ActionCardError(403, 'Conversation is not available for this agent', 'CONVERSATION_NOT_AVAILABLE');
+    }
+    const now = Date.now();
+    const expiresAt = params.expiresAt && params.expiresAt > now
+        ? params.expiresAt
+        : now + 24 * 60 * 60 * 1000;
+    const reason = normalizeReason(params.reason);
+    const id = randomUUID();
+    db.prepare(`INSERT INTO action_cards(
+       id, action_type, payload_json, origin_conversation_id, origin_channel_id,
+       origin_thread_root_id, proposer_agent_id, run_id, turn_id, trace_id, reason, status, expires_at,
+       created_at, updated_at
+     )
+     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)`).run(id, actionType, JSON.stringify(payload), conversation.id, conversation.channelId ?? null, conversation.threadRootId ?? null, params.proposerAgentId, params.runId ?? null, params.turnId ?? null, params.traceId ?? null, reason, expiresAt, now, now);
+    const card = getActionCardById(db, id);
+    if (!card)
+        throw new ActionCardError(500, 'Action card was not persisted');
+    const panelId = insertActionCardPanel(db, card);
+    return {
+        card: {
+            ...toPublicActionCard(card),
+            panelId,
+            panel_id: panelId,
+            summary: summarizeAction(actionType, payload),
+        },
+        panelId,
+    };
+}
+export function expireDueActionCards(db, now = Date.now()) {
+    const result = db.prepare(`UPDATE action_cards
+        SET status = 'expired',
+            updated_at = ?,
+            failed_at = COALESCE(failed_at, ?)
+      WHERE status = 'pending'
+        AND expires_at <= ?`).run(now, now, now);
+    return Number(result.changes ?? 0);
+}
+function writeActionCardResultMessage(db, params) {
+    if (!params.card.originChannelId)
+        return null;
+    const channelId = params.card.originChannelId;
+    const channel = db.prepare(`SELECT name FROM channels WHERE channel_id = ? LIMIT 1`).get(channelId);
+    const target = channel
+        ? `#${channel.name}${params.card.originThreadRootId ? `:${params.card.originThreadRootId}` : ''}`
+        : (params.card.originThreadRootId ? `#${channelId}:${params.card.originThreadRootId}` : `#${channelId}`);
+    const createdAt = Date.now();
+    const messageId = randomUUID();
+    const seq = allocateNextChannelMessageSeq(db, channelId);
+    const content = params.status === 'confirmed'
+        ? `Action confirmed by ${params.actorName}: ${summarizeAction(params.card.actionType, params.card.payload)}.`
+        : `Action ${params.status} by ${params.actorName}: ${summarizeAction(params.card.actionType, params.card.payload)}.`;
+    db.prepare(`INSERT INTO channel_messages(
+       message_id, channel_id, sender_id, sender_name, sender_type, target, content,
+       seq, created_at, thread_root_id, message_kind, message_source
+     )
+     VALUES(?, ?, 'system', 'Bigbang', 'system', ?, ?, ?, ?, ?, 'system', 'action_card')`).run(messageId, channelId, target, content, seq, createdAt, params.card.originThreadRootId);
+    params.broadcastToChannel?.(channelId, {
+        type: 'channel.message',
+        message: {
+            id: messageId,
+            senderName: 'Bigbang',
+            senderType: 'system',
+            content,
+            createdAt: new Date(createdAt).toISOString(),
+            seq,
+            messageKind: 'system',
+            messageSource: 'action_card',
+            ...(params.card.originThreadRootId ? { threadRootId: params.card.originThreadRootId } : {}),
+        },
+    });
+    return messageId;
+}
+function executeActionCard(card, conversationManager) {
+    switch (card.actionType) {
+        case 'channel:create': {
+            const payload = normalizeChannelCreatePayload(card.payload);
+            const channel = conversationManager.createChannel({
+                name: payload.name,
+                workspacePath: payload.workspacePath,
+                description: payload.description,
+                collaborationMode: payload.collaborationMode,
+            });
+            for (const agentId of payload.agentIds ?? []) {
+                if (conversationManager.getAgent(agentId))
+                    conversationManager.joinChannel(agentId, channel.channelId);
+            }
+            return { channel: conversationManager.getChannel(channel.channelId) ?? channel };
+        }
+        case 'agent:create': {
+            const agent = conversationManager.createAgent(normalizeAgentCreatePayload(card.payload));
+            return { agent };
+        }
+        case 'channel:add_member': {
+            const payload = normalizeAddMemberPayload(card.payload);
+            const channel = conversationManager.getChannel(payload.channelId);
+            if (!channel)
+                throw new ActionCardError(404, 'Channel not found', 'CHANNEL_NOT_FOUND');
+            const agent = conversationManager.getAgent(payload.agentId);
+            if (!agent)
+                throw new ActionCardError(404, 'Agent not found', 'AGENT_NOT_FOUND');
+            conversationManager.joinChannel(payload.agentId, payload.channelId);
+            return { channel: conversationManager.getChannel(payload.channelId), agent };
+        }
+    }
+}
+function updateActionCardFailed(db, cardId, message, now) {
+    db.prepare(`UPDATE action_cards
+        SET status = 'failed', result_json = ?, updated_at = ?, failed_at = ?
+      WHERE id = ? AND status = 'pending'`).run(JSON.stringify({ error: message }), now, now, cardId);
+}
+export function confirmActionCard(db, params) {
+    const tx = db.transaction(() => {
+        const card = getActionCardById(db, params.id);
+        if (!card)
+            throw new ActionCardError(404, 'Action card not found', 'ACTION_CARD_NOT_FOUND');
+        const now = Date.now();
+        if (card.status !== 'pending') {
+            throw new ActionCardError(409, `Action card is ${card.status}`, 'ACTION_CARD_NOT_PENDING');
+        }
+        if (card.expiresAt <= now) {
+            const updated = db.prepare(`UPDATE action_cards
+            SET status = 'expired', updated_at = ?, failed_at = ?
+          WHERE id = ? AND status = 'pending'`).run(now, now, card.id);
+            if (updated.changes !== 1) {
+                throw new ActionCardError(409, 'Action card is no longer pending', 'ACTION_CARD_NOT_PENDING');
+            }
+            writeActionCardResultMessage(db, {
+                card: { ...card, status: 'expired' },
+                status: 'expired',
+                actorName: params.confirmedByName,
+                broadcastToChannel: params.broadcastToChannel,
+            });
+            return new ActionCardError(409, 'Action card expired', 'ACTION_CARD_EXPIRED');
+        }
+        try {
+            const result = executeActionCard(card, params.conversationManager);
+            const updated = db.prepare(`UPDATE action_cards
+            SET status = 'confirmed', confirmed_by = ?, result_json = ?,
+                updated_at = ?, confirmed_at = ?
+          WHERE id = ? AND status = 'pending'`).run(params.confirmedBy, JSON.stringify(result), now, now, card.id);
+            if (updated.changes !== 1) {
+                throw new ActionCardError(409, 'Action card is no longer pending', 'ACTION_CARD_NOT_PENDING');
+            }
+            const confirmedCard = getActionCardById(db, card.id) ?? { ...card, status: 'confirmed', result };
+            const resultMessageId = writeActionCardResultMessage(db, {
+                card: confirmedCard,
+                status: 'confirmed',
+                actorName: params.confirmedByName,
+                result,
+                broadcastToChannel: params.broadcastToChannel,
+            });
+            return {
+                ok: true,
+                card: toPublicActionCard(confirmedCard),
+                result,
+                resultMessageId,
+                result_message_id: resultMessageId,
+            };
+        }
+        catch (error) {
+            if (error instanceof ActionCardError && error.errorCode === 'ACTION_CARD_NOT_PENDING') {
+                throw error;
+            }
+            const statusCode = error instanceof ActionCardError ? error.statusCode : 500;
+            const message = String(error?.message ?? error);
+            updateActionCardFailed(db, card.id, message, now);
+            writeActionCardResultMessage(db, {
+                card: { ...card, status: 'failed', result: { error: message } },
+                status: 'failed',
+                actorName: params.confirmedByName,
+                broadcastToChannel: params.broadcastToChannel,
+            });
+            return new ActionCardError(statusCode, message, error instanceof ActionCardError ? error.errorCode : 'ACTION_CARD_EXECUTION_FAILED');
+        }
+    });
+    const result = tx();
+    if (result instanceof ActionCardError)
+        throw result;
+    return result;
+}
+export function cancelActionCard(db, params) {
+    const tx = db.transaction(() => {
+        expireDueActionCards(db);
+        const card = getActionCardById(db, params.id);
+        if (!card)
+            throw new ActionCardError(404, 'Action card not found', 'ACTION_CARD_NOT_FOUND');
+        if (card.status !== 'pending') {
+            throw new ActionCardError(409, `Action card is ${card.status}`, 'ACTION_CARD_NOT_PENDING');
+        }
+        const now = Date.now();
+        const updated = db.prepare(`UPDATE action_cards
+          SET status = 'cancelled', confirmed_by = ?, updated_at = ?, cancelled_at = ?
+        WHERE id = ? AND status = 'pending'`).run(params.cancelledBy, now, now, card.id);
+        if (updated.changes !== 1) {
+            throw new ActionCardError(409, 'Action card is no longer pending', 'ACTION_CARD_NOT_PENDING');
+        }
+        const cancelledCard = getActionCardById(db, card.id) ?? { ...card, status: 'cancelled' };
+        const resultMessageId = writeActionCardResultMessage(db, {
+            card: cancelledCard,
+            status: 'cancelled',
+            actorName: params.cancelledByName,
+            broadcastToChannel: params.broadcastToChannel,
+        });
+        return {
+            ok: true,
+            card: toPublicActionCard(cancelledCard),
+            resultMessageId,
+            result_message_id: resultMessageId,
+        };
+    });
+    return tx();
+}