@bbigbang/core 0.1.0

package/dist/services/workspaceToolPublishIdentityResolver.js

@@ -0,0 +1,146 @@
+import { resolveWorkspaceToolPublishIdentityState, } from './workspaceToolPromotionState.js';
+export class WorkspaceToolPublishIdentityResolver {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    resolve(params) {
+        const promotionLink = params.sourceConversationId
+            ? this.loadPanelPromotionByConversation(params.sourceConversationId)
+            : null;
+        const existingByMaintenanceConversation = params.sourceConversationId
+            ? this.loadWorkspaceToolIdentityByMaintenanceConversation(params.userId, params.agentId, params.sourceConversationId)
+            : undefined;
+        const linkedTool = promotionLink?.toolId
+            ? this.loadLiveWorkspaceToolIdentityByToolId(promotionLink.toolId)
+            : undefined;
+        const sourcePanelId = promotionLink?.panelId
+            ?? linkedTool?.sourcePanelId
+            ?? existingByMaintenanceConversation?.sourcePanelId
+            ?? null;
+        const existingByPanelId = sourcePanelId
+            ? this.loadWorkspaceToolIdentityByPanelId(params.userId, params.agentId, sourcePanelId)
+            : undefined;
+        const collaboratorSlug = this.loadWorkspaceToolIdentityByCollaboratorSlug(params.userId, params.agentId, params.slug);
+        const existingByCollaboratorSlug = collaboratorSlug.row;
+        const existingBySlug = this.loadOwnedWorkspaceToolIdentityBySlug(params.userId, params.agentId, params.slug);
+        const publishState = resolveWorkspaceToolPublishIdentityState({
+            promotionLink,
+            linkedTool,
+            existingByMaintenanceConversation,
+            existingByPanelId,
+            existingByCollaboratorSlug,
+            existingBySlug,
+            allowCreateNewTool: params.allowCreateNewTool,
+        });
+        return {
+            promotionLink,
+            existingByMaintenanceConversation,
+            existingByPanelId,
+            existingByCollaboratorSlug,
+            existingBySlug,
+            linkedTool,
+            sourcePanelId,
+            loadConflict: collaboratorSlug.conflict,
+            publishState,
+        };
+    }
+    loadPanelPromotionByConversation(conversationId) {
+        return this.db.prepare(`SELECT ptp.panel_id as panelId,
+              ptp.user_id as userId,
+              ptp.agent_id as agentId,
+              ptp.promotion_conversation_id as promotionConversationId,
+              ptp.tool_id as linkedToolId,
+              wt.deleted_at as linkedToolDeletedAt,
+              CASE WHEN wt.deleted_at IS NULL THEN wt.tool_id ELSE NULL END as toolId,
+              CASE WHEN wt.deleted_at IS NULL THEN wt.name ELSE NULL END as toolName,
+              CASE WHEN wt.deleted_at IS NULL THEN wt.revision ELSE NULL END as toolRevision,
+              CASE WHEN wt.deleted_at IS NULL THEN wt.maintenance_conversation_id ELSE NULL END as maintenanceConversationId,
+              ptp.created_at as createdAt,
+              ptp.updated_at as updatedAt
+         FROM panel_tool_promotions ptp
+         LEFT JOIN workspace_tools wt
+           ON wt.tool_id = ptp.tool_id
+        WHERE ptp.promotion_conversation_id = ?
+           OR wt.maintenance_conversation_id = ?
+        LIMIT 1`).get(conversationId, conversationId) ?? null;
+    }
+    loadWorkspaceToolIdentityByMaintenanceConversation(userId, agentId, maintenanceConversationId) {
+        return this.db.prepare(`${workspaceToolIdentitySelectSql()}
+        WHERE user_id = ?
+          AND agent_id = ?
+          AND maintenance_conversation_id = ?
+        ORDER BY deleted_at IS NULL DESC, updated_at DESC
+        LIMIT 1`).get(userId, agentId, maintenanceConversationId);
+    }
+    loadLiveWorkspaceToolIdentityByToolId(toolId) {
+        return this.db.prepare(`${workspaceToolIdentitySelectSql()}
+        WHERE tool_id = ?
+          AND deleted_at IS NULL
+        LIMIT 1`).get(toolId);
+    }
+    loadWorkspaceToolIdentityByPanelId(userId, agentId, panelId) {
+        return this.db.prepare(`${workspaceToolIdentitySelectSql()}
+        WHERE user_id = ?
+          AND agent_id = ?
+          AND source_panel_id = ?
+        ORDER BY deleted_at IS NULL DESC, updated_at DESC
+        LIMIT 1`).get(userId, agentId, panelId);
+    }
+    loadWorkspaceToolIdentityByCollaboratorSlug(userId, agentId, slug) {
+        const rows = this.db.prepare(`SELECT wt.tool_id as toolId,
+              wt.user_id as userId,
+              wt.agent_id as agentId,
+              wt.source_panel_id as sourcePanelId,
+              wt.panel_id as panelId,
+              wt.slug,
+              wt.active_terminal_id as activeTerminalId,
+              wt.maintenance_conversation_id as maintenanceConversationId,
+              wt.revision,
+              wt.deleted_at as deletedAt
+         FROM workspace_tools wt
+         JOIN surface_collaborators sc
+           ON sc.surface_type = 'tool'
+          AND sc.surface_id = wt.tool_id
+          AND sc.agent_id = ?
+        WHERE wt.user_id = ?
+          AND wt.slug = ?
+          AND wt.agent_id != ?
+          AND wt.deleted_at IS NULL
+        ORDER BY wt.updated_at DESC, wt.created_at DESC`).all(agentId, userId, slug, agentId);
+        if (rows.length > 1) {
+            return {
+                row: null,
+                conflict: {
+                    kind: 'ambiguous_collaborator_slug',
+                    message: `Multiple tools named "${slug}" list this agent as a maintainer; publish from the owner maintenance chat to disambiguate.`,
+                    statusCode: 409,
+                },
+            };
+        }
+        return {
+            row: rows[0] ?? null,
+            conflict: null,
+        };
+    }
+    loadOwnedWorkspaceToolIdentityBySlug(userId, agentId, slug) {
+        return this.db.prepare(`${workspaceToolIdentitySelectSql()}
+        WHERE user_id = ?
+          AND agent_id = ?
+          AND slug = ?
+        LIMIT 1`).get(userId, agentId, slug);
+    }
+}
+function workspaceToolIdentitySelectSql() {
+    return `SELECT tool_id as toolId,
+                 user_id as userId,
+                 agent_id as agentId,
+                 source_panel_id as sourcePanelId,
+                 panel_id as panelId,
+                 slug,
+                 active_terminal_id as activeTerminalId,
+                 maintenance_conversation_id as maintenanceConversationId,
+                 revision,
+                 deleted_at as deletedAt
+            FROM workspace_tools`;
+}

package/dist/services/workspaceToolReadModel.js

@@ -0,0 +1,378 @@
+import { getUserAgentAccess, getUserChannelAccess } from './auth.js';
+import { parseStateRowJson, runRowToInfo, } from './workspaceToolExecutionUtils.js';
+import { parseWorkspaceToolManifest, resolveWorkspaceToolActionMode, sanitizeWorkspaceToolManifestForViewer, } from './workspaceToolManifest.js';
+import { deriveWorkspaceToolBusinessState, deriveWorkspaceToolRuntimeState, } from './workspaceToolPanelProjection.js';
+const WORKSPACE_TOOL_ROW_SELECT = `
+  wt.tool_id as toolId,
+  wt.user_id as userId,
+  wt.agent_id as agentId,
+  a.name as agentName,
+  a.node_id as agentNodeId,
+  a.workspace_path as agentWorkspacePath,
+  a.deleted_at as agentDeletedAt,
+  n.status as agentNodeStatus,
+  wt.source_panel_id as sourcePanelId,
+  wt.panel_id as panelId,
+  wt.slug,
+  wt.name,
+  wt.description,
+  wt.icon,
+  wt.scope,
+  wt.scope_channel_id as scopeChannelId,
+  wt.allow_shared_exec as allowSharedExec,
+  wt.public_review_status as publicReviewStatus,
+  wt.pending_public_review as pendingPublicReview,
+  wt.manifest_path as manifestPath,
+  wt.bundle_root as bundleRoot,
+  wt.manifest_json as manifestJson,
+  wt.latest_state_json as latestStateJson,
+  wt.active_terminal_id as activeTerminalId,
+  wt.maintenance_conversation_id as maintenanceConversationId,
+  wt.source_conversation_id as sourceConversationId,
+  wt.source_message_id as sourceMessageId,
+  wt.cloned_from_tool_id as clonedFromToolId,
+  wt.cloned_from_revision as clonedFromRevision,
+  wt.revision,
+  wt.created_at as createdAt,
+  wt.updated_at as updatedAt,
+  wt.deleted_at as deletedAt
+`;
+function parseVerificationDetails(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function workspaceToolRunRowToInfoForViewer(row, actionKind, params) {
+    const info = runRowToInfo(row, actionKind);
+    const canViewOwnerFields = params.canViewOwnerFields === true || params.viewerUserId === params.ownerUserId;
+    const canViewRunInvocation = canViewOwnerFields || params.viewerUserId === (row.requestedByUserId ?? null);
+    const visibleInfo = canViewOwnerFields ? info : { ...info, executionWorkspacePath: null };
+    if (canViewRunInvocation) {
+        return visibleInfo;
+    }
+    return {
+        ...visibleInfo,
+        terminalId: null,
+        params: null,
+        requestedByUserId: null,
+        requestedByUsername: null,
+        requestedByAgentId: null,
+        requestedByAgentName: null,
+    };
+}
+export class WorkspaceToolReadModel {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    loadUsername(userId) {
+        const row = this.db.prepare(`SELECT username
+         FROM users
+        WHERE id = ?`).get(userId);
+        return row?.username ?? null;
+    }
+    isAdminUser(userId) {
+        const row = this.db.prepare(`SELECT is_admin as isAdmin
+         FROM users
+        WHERE id = ?`).get(userId);
+        return row?.isAdmin === 1;
+    }
+    loadToolRowForUser(userId, toolId) {
+        return this.db.prepare(`SELECT ${WORKSPACE_TOOL_ROW_SELECT}
+         FROM workspace_tools wt
+         LEFT JOIN agents a ON a.agent_id = wt.agent_id
+         LEFT JOIN nodes n ON n.node_id = a.node_id
+        WHERE wt.tool_id = ?
+          AND wt.user_id = ?
+          AND wt.deleted_at IS NULL
+        LIMIT 1`).get(toolId, userId) ?? null;
+    }
+    loadToolRowById(toolId) {
+        return this.db.prepare(`SELECT ${WORKSPACE_TOOL_ROW_SELECT}
+         FROM workspace_tools wt
+         LEFT JOIN agents a ON a.agent_id = wt.agent_id
+         LEFT JOIN nodes n ON n.node_id = a.node_id
+        WHERE wt.tool_id = ?
+          AND wt.deleted_at IS NULL
+        LIMIT 1`).get(toolId) ?? null;
+    }
+    loadToolRowForViewer(userId, toolId, options) {
+        if (options?.allowAdminBypass && this.isAdminUser(userId)) {
+            return this.loadToolRowById(toolId);
+        }
+        const allowedChannelIds = getUserChannelAccess(this.db, userId);
+        const rows = this.loadVisibleToolRowsForViewer(userId, {
+            toolIds: [toolId],
+            allowedChannelIds,
+        });
+        return rows[0] ?? null;
+    }
+    loadToolRowByPanelIdForViewer(userId, panelId) {
+        if (this.isAdminUser(userId)) {
+            return this.db.prepare(`SELECT ${WORKSPACE_TOOL_ROW_SELECT}
+           FROM workspace_tools wt
+           LEFT JOIN agents a ON a.agent_id = wt.agent_id
+           LEFT JOIN nodes n ON n.node_id = a.node_id
+          WHERE wt.panel_id = ?
+            AND wt.deleted_at IS NULL
+          LIMIT 1`).get(panelId) ?? null;
+        }
+        const allowedChannelIds = getUserChannelAccess(this.db, userId);
+        const rows = this.loadVisibleToolRowsForViewer(userId, {
+            panelIds: [panelId],
+            allowedChannelIds,
+        });
+        return rows[0] ?? null;
+    }
+    loadVisibleToolRowsForViewer(userId, options) {
+        const allowedChannelIds = options?.allowedChannelIds ?? getUserChannelAccess(this.db, userId);
+        const conditions = ['wt.deleted_at IS NULL'];
+        const params = [];
+        if (options?.toolIds?.length) {
+            const normalizedToolIds = [...new Set(options.toolIds.map((toolId) => toolId.trim()).filter(Boolean))];
+            if (normalizedToolIds.length === 0)
+                return [];
+            conditions.push(`wt.tool_id IN (${normalizedToolIds.map(() => '?').join(', ')})`);
+            params.push(...normalizedToolIds);
+        }
+        if (options?.panelIds?.length) {
+            const normalizedPanelIds = [...new Set(options.panelIds.map((panelId) => panelId.trim()).filter(Boolean))];
+            if (normalizedPanelIds.length === 0)
+                return [];
+            conditions.push(`wt.panel_id IN (${normalizedPanelIds.map(() => '?').join(', ')})`);
+            params.push(...normalizedPanelIds);
+        }
+        const visibilityClauses = [
+            'wt.user_id = ?',
+            `(wt.scope = 'public' AND wt.public_review_status = 'approved' AND wt.pending_public_review = 0)`,
+        ];
+        const visibilityParams = [userId];
+        if (allowedChannelIds.length > 0) {
+            visibilityClauses.push(`(wt.scope = 'channel' AND wt.scope_channel_id IN (${allowedChannelIds.map(() => '?').join(', ')}))`);
+            visibilityParams.push(...allowedChannelIds);
+        }
+        conditions.push(`(${visibilityClauses.join(' OR ')})`);
+        return this.db.prepare(`SELECT ${WORKSPACE_TOOL_ROW_SELECT}
+         FROM workspace_tools wt
+         LEFT JOIN agents a ON a.agent_id = wt.agent_id
+         LEFT JOIN nodes n ON n.node_id = a.node_id
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY wt.updated_at DESC, wt.created_at DESC`).all(...params, ...visibilityParams);
+    }
+    loadPublicReviewToolRows(status = 'pending_review') {
+        const statusCondition = status === 'pending_review'
+            ? 'wt.pending_public_review = 1'
+            : 'wt.pending_public_review = 0 AND wt.public_review_status = ?';
+        return this.db.prepare(`SELECT ${WORKSPACE_TOOL_ROW_SELECT}
+         FROM workspace_tools wt
+         LEFT JOIN agents a ON a.agent_id = wt.agent_id
+         LEFT JOIN nodes n ON n.node_id = a.node_id
+        WHERE wt.deleted_at IS NULL
+          AND ${statusCondition}
+        ORDER BY wt.updated_at DESC, wt.created_at DESC`).all(...(status === 'pending_review' ? [] : [status]));
+    }
+    canManageToolCollaborators(userId, row) {
+        return row.userId === userId || this.isAdminUser(userId);
+    }
+    canManageToolForViewer(userId, row) {
+        if (row.userId === userId || this.isAdminUser(userId))
+            return true;
+        return this.userCanManageToolViaMaintainerAgent(userId, row.toolId);
+    }
+    rowToToolInfo(row) {
+        return this.rowToToolInfoForViewer(row, row.userId);
+    }
+    rowToToolInfoForViewer(row, viewerUserId) {
+        const manifest = parseWorkspaceToolManifest(row.manifestJson);
+        const isOwner = row.userId === viewerUserId;
+        const canManage = this.canManageToolForViewer(viewerUserId, row);
+        const canViewOwnerFields = isOwner || this.isAdminUser(viewerUserId);
+        const lastRunRow = this.db.prepare(`SELECT run_id as runId,
+              wtr.tool_id as toolId,
+              action_id as actionId,
+              terminal_id as terminalId,
+              status,
+              params_json as paramsJson,
+              exit_code as exitCode,
+              signal,
+              started_at as startedAt,
+              ended_at as endedAt,
+              requested_by_user_id as requestedByUserId,
+              u.username as requestedByUsername,
+              requested_by_agent_id as requestedByAgentId,
+              a.name as requestedByAgentName,
+              execution_target_kind as executionTargetKind,
+              execution_agent_id as executionAgentId,
+              execution_node_id as executionNodeId,
+              execution_hostname as executionHostname,
+              execution_workspace_path as executionWorkspacePath
+         FROM workspace_tool_runs wtr
+         LEFT JOIN users u ON u.id = wtr.requested_by_user_id
+         LEFT JOIN agents a ON a.agent_id = wtr.requested_by_agent_id
+        WHERE wtr.tool_id = ?
+        ORDER BY started_at DESC
+        LIMIT 1`).get(row.toolId);
+        const latestState = parseStateRowJson(row.latestStateJson);
+        const verification = this.loadLatestVerificationForTool(row.toolId, row.revision);
+        const runtimeState = deriveWorkspaceToolRuntimeState({
+            activeTerminalId: row.activeTerminalId,
+            lastRunStatus: lastRunRow?.status ?? null,
+        });
+        return {
+            toolId: row.toolId,
+            userId: row.userId,
+            agentId: row.agentId,
+            agentName: row.agentName ?? null,
+            agentNodeId: row.agentNodeId ?? null,
+            agentHealth: {
+                isOnline: row.agentNodeStatus === 'online',
+                isDeleted: row.agentDeletedAt != null,
+                hasNode: Boolean(row.agentNodeId?.trim()),
+                hasWorkspace: Boolean(row.agentWorkspacePath?.trim()),
+            },
+            sourcePanelId: row.sourcePanelId ?? null,
+            panelId: row.panelId ?? null,
+            slug: row.slug,
+            name: row.name,
+            description: row.description,
+            icon: row.icon ?? null,
+            scope: row.scope,
+            scopeChannelId: row.scopeChannelId ?? null,
+            allowSharedExec: row.allowSharedExec === 1,
+            publicReviewStatus: row.publicReviewStatus,
+            pendingPublicReview: row.pendingPublicReview === 1,
+            isOwner,
+            canManage,
+            manifestPath: canViewOwnerFields ? row.manifestPath : null,
+            bundleRoot: canViewOwnerFields ? row.bundleRoot : null,
+            backendRuntime: manifest.actions.length === 0 ? 'none' : manifest.cli?.entry?.trim() ? 'cli' : 'command',
+            actionBackendRuntimes: Object.fromEntries(manifest.actions.map((action) => [
+                action.actionId,
+                resolveWorkspaceToolActionMode(action) === 'notify_agent'
+                    ? 'none'
+                    : action.command?.trim()
+                        ? 'command'
+                        : manifest.cli?.entry?.trim()
+                            ? 'cli'
+                            : action.kind === 'stop'
+                                ? 'none'
+                                : 'command',
+            ])),
+            manifest: sanitizeWorkspaceToolManifestForViewer(manifest, {
+                scope: row.scope,
+                scopeChannelId: row.scopeChannelId ?? null,
+                allowSharedExec: row.allowSharedExec === 1,
+                isOwner: canViewOwnerFields,
+            }),
+            latestState,
+            businessState: deriveWorkspaceToolBusinessState(latestState),
+            runtimeState,
+            isRunning: row.activeTerminalId != null,
+            activeTerminalId: canViewOwnerFields ? (row.activeTerminalId ?? null) : null,
+            maintenanceConversationId: canViewOwnerFields ? (row.maintenanceConversationId ?? null) : null,
+            sourceConversationId: canViewOwnerFields ? (row.sourceConversationId ?? null) : null,
+            sourceMessageId: canViewOwnerFields ? (row.sourceMessageId ?? null) : null,
+            clonedFromToolId: canViewOwnerFields ? (row.clonedFromToolId ?? null) : null,
+            clonedFromRevision: canViewOwnerFields ? (row.clonedFromRevision ?? null) : null,
+            verification: verification
+                ? {
+                    verificationId: verification.verificationId,
+                    toolId: verification.toolId,
+                    toolRevision: verification.toolRevision,
+                    sourceToolId: canViewOwnerFields ? verification.sourceToolId : null,
+                    sourceRevision: canViewOwnerFields ? verification.sourceRevision : null,
+                    targetAgentId: verification.targetAgentId,
+                    targetNodeId: verification.targetNodeId,
+                    targetWorkspacePath: canViewOwnerFields ? verification.targetWorkspacePath : null,
+                    conversationId: canViewOwnerFields ? verification.conversationId : null,
+                    status: verification.status,
+                    summary: verification.summary,
+                    details: canViewOwnerFields ? parseVerificationDetails(verification.detailsJson) : null,
+                    smokeRunId: canViewOwnerFields ? verification.smokeRunId : null,
+                    startedAt: verification.startedAt,
+                    endedAt: verification.endedAt,
+                    updatedAt: verification.updatedAt,
+                }
+                : null,
+            revision: row.revision,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+            deletedAt: row.deletedAt ?? null,
+            lastRun: lastRunRow
+                ? workspaceToolRunRowToInfoForViewer(lastRunRow, manifest.actions.find((action) => action.actionId === lastRunRow.actionId)?.kind, {
+                    viewerUserId,
+                    ownerUserId: row.userId,
+                    canViewOwnerFields,
+                })
+                : null,
+        };
+    }
+    loadLatestVerificationForTool(toolId, toolRevision) {
+        return this.db.prepare(`SELECT verification_id as verificationId,
+              tool_id as toolId,
+              tool_revision as toolRevision,
+              source_tool_id as sourceToolId,
+              source_revision as sourceRevision,
+              target_agent_id as targetAgentId,
+              target_node_id as targetNodeId,
+              target_workspace_path as targetWorkspacePath,
+              conversation_id as conversationId,
+              status,
+              summary,
+              details_json as detailsJson,
+              smoke_run_id as smokeRunId,
+              started_at as startedAt,
+              ended_at as endedAt,
+              updated_at as updatedAt
+         FROM workspace_tool_verifications
+        WHERE tool_id = ?
+          AND tool_revision = ?
+        ORDER BY updated_at DESC, started_at DESC
+        LIMIT 1`).get(toolId, toolRevision) ?? null;
+    }
+    loadVerificationByConversation(conversationId) {
+        return this.db.prepare(`SELECT verification_id as verificationId,
+              tool_id as toolId,
+              tool_revision as toolRevision,
+              source_tool_id as sourceToolId,
+              source_revision as sourceRevision,
+              target_agent_id as targetAgentId,
+              target_node_id as targetNodeId,
+              target_workspace_path as targetWorkspacePath,
+              conversation_id as conversationId,
+              status,
+              summary,
+              details_json as detailsJson,
+              smoke_run_id as smokeRunId,
+              started_at as startedAt,
+              ended_at as endedAt,
+              updated_at as updatedAt
+         FROM workspace_tool_verifications
+        WHERE conversation_id = ?
+        ORDER BY updated_at DESC, started_at DESC
+        LIMIT 1`).get(conversationId) ?? null;
+    }
+    userCanManageToolViaMaintainerAgent(userId, toolId) {
+        const accessibleAgentIds = getUserAgentAccess(this.db, userId)
+            .map((agentId) => agentId.trim())
+            .filter(Boolean);
+        if (accessibleAgentIds.length === 0)
+            return false;
+        const row = this.db.prepare(`SELECT 1 as present
+         FROM surface_collaborators
+        WHERE surface_type = 'tool'
+          AND surface_id = ?
+          AND role = 'collaborator'
+          AND agent_id IN (${accessibleAgentIds.map(() => '?').join(', ')})
+        LIMIT 1`).get(toolId, ...accessibleAgentIds);
+        return Boolean(row);
+    }
+}