clawdentials-mcp 0.7.2 → 0.8.1

package/dist/tools/bounty.js

@@ -0,0 +1,608 @@
+import { bountyCreateSchema, bountyFundSchema, bountyClaimSchema, bountySubmitSchema, bountyJudgeSchema, bountySearchSchema, bountyGetSchema, bountyExportMarkdownSchema, } from '../schemas/index.js';
+import { validateApiKey, getBalance, debitBalance, creditBalance, getDb, } from '../services/firestore.js';
+import { Timestamp } from 'firebase-admin/firestore';
+const CLAIM_LOCK_HOURS = 24;
+// Helper to get bounties collection
+const bountiesCollection = () => getDb().collection('bounties');
+// Helper to convert Firestore doc to Bounty
+function docToBounty(doc) {
+    if (!doc.exists)
+        return null;
+    const data = doc.data();
+    return {
+        id: doc.id,
+        title: data.title,
+        summary: data.summary,
+        description: data.description,
+        difficulty: data.difficulty,
+        requiredSkills: data.requiredSkills || [],
+        tags: data.tags,
+        repoUrl: data.repoUrl,
+        files: data.files,
+        acceptanceCriteria: data.acceptanceCriteria || [],
+        submissionMethod: data.submissionMethod,
+        targetBranch: data.targetBranch,
+        amount: data.amount,
+        currency: data.currency,
+        escrowId: data.escrowId,
+        createdAt: data.createdAt?.toDate() || new Date(),
+        expiresAt: data.expiresAt?.toDate() || new Date(),
+        completedAt: data.completedAt?.toDate(),
+        posterAgentId: data.posterAgentId,
+        modAgentId: data.modAgentId,
+        status: data.status,
+        claims: (data.claims || []).map((c) => ({
+            ...c,
+            claimedAt: c.claimedAt?.toDate() || new Date(),
+            expiresAt: c.expiresAt?.toDate() || new Date(),
+            submittedAt: c.submittedAt?.toDate(),
+        })),
+        winnerAgentId: data.winnerAgentId,
+        winnerSubmissionUrl: data.winnerSubmissionUrl,
+        viewCount: data.viewCount || 0,
+        claimCount: data.claimCount || 0,
+    };
+}
+// Generate markdown export of a bounty
+function bountyToMarkdown(bounty) {
+    const statusEmoji = {
+        draft: '📝',
+        open: '🟢',
+        claimed: '🔒',
+        in_review: '👀',
+        completed: '✅',
+        expired: '⏰',
+        cancelled: '❌',
+    };
+    const filesSection = bounty.files?.length
+        ? `**Files:**\n${bounty.files.map(f => `- \`${f.path}\`${f.description ? ` - ${f.description}` : ''}`).join('\n')}`
+        : '';
+    const acceptanceCriteriaSection = bounty.acceptanceCriteria
+        .map(c => `- [ ] ${c}`)
+        .join('\n');
+    const claimsSection = bounty.claims.length
+        ? bounty.claims
+            .filter(c => c.status === 'submitted')
+            .map(c => `- ${c.agentId}: [${c.submissionUrl}](${c.submissionUrl})`)
+            .join('\n')
+        : 'No submissions yet.';
+    return `# Bounty: ${bounty.id}
+
+## ${bounty.title}
+
+## Meta
+- **Status:** ${statusEmoji[bounty.status] || ''} ${bounty.status}
+- **Posted:** ${bounty.createdAt.toISOString().split('T')[0]}
+- **Expires:** ${bounty.expiresAt.toISOString().split('T')[0]}
+- **Reward:** ${bounty.amount} ${bounty.currency}
+- **Difficulty:** ${bounty.difficulty}
+- **Escrow ID:** ${bounty.escrowId || 'Not funded'}
+
+## Required Skills
+${bounty.requiredSkills.map(s => `- ${s}`).join('\n')}
+
+## Summary
+
+${bounty.summary}
+
+## Task
+
+${bounty.description}
+
+## Context
+
+${bounty.repoUrl ? `**Repo:** ${bounty.repoUrl}` : ''}
+${filesSection}
+
+## Acceptance Criteria
+
+${acceptanceCriteriaSection}
+
+## Submission
+
+**Method:** ${bounty.submissionMethod}
+${bounty.targetBranch ? `**Target Branch:** ${bounty.targetBranch}` : ''}
+
+**Include:**
+- Link to submission
+- Agent ID (Clawdentials)
+- Brief description of approach
+
+## Judging
+
+**Mod Agent:** ${bounty.modAgentId || 'Poster (self-moderated)'}
+
+## Current Submissions
+
+${claimsSection}
+
+${bounty.winnerAgentId ? `## Winner\n\n🏆 **${bounty.winnerAgentId}**\nSubmission: ${bounty.winnerSubmissionUrl}` : ''}
+
+## Claim Instructions
+
+\`\`\`bash
+# 1. Register if you haven't
+npx clawdentials-mcp --register "YourAgentName" --skills "${bounty.requiredSkills.join(',')}"
+
+# 2. Use MCP tools to claim and submit
+# bounty_claim: bountyId="${bounty.id}"
+# bounty_submit: bountyId="${bounty.id}", submissionUrl="<your-pr-url>"
+\`\`\`
+
+---
+
+**Posted by:** ${bounty.posterAgentId}
+**Escrow funded:** ${bounty.escrowId ? '✓' : '✗'}
+**Views:** ${bounty.viewCount} | **Claims:** ${bounty.claimCount}
+${bounty.tags?.length ? `**Tags:** ${bounty.tags.join(', ')}` : ''}
+`;
+}
+export const bountyTools = {
+    bounty_create: {
+        description: 'Create a new bounty for agents to claim. Optionally fund it immediately from your balance.',
+        inputSchema: bountyCreateSchema,
+        handler: async (input) => {
+            try {
+                // Validate API key
+                const isValid = await validateApiKey(input.posterAgentId, input.apiKey);
+                if (!isValid) {
+                    return { success: false, error: 'Invalid API key' };
+                }
+                // If funding now, check balance
+                if (input.fundNow) {
+                    const balance = await getBalance(input.posterAgentId);
+                    if (balance < input.amount) {
+                        return {
+                            success: false,
+                            error: `Insufficient balance. Have: ${balance}, need: ${input.amount}`,
+                        };
+                    }
+                }
+                const now = new Date();
+                const expiresAt = new Date(now.getTime() + (input.expiresInDays || 7) * 24 * 60 * 60 * 1000);
+                // Build bounty data, excluding undefined values
+                const bountyData = {
+                    title: input.title,
+                    summary: input.summary,
+                    description: input.description,
+                    difficulty: input.difficulty,
+                    requiredSkills: input.requiredSkills,
+                    acceptanceCriteria: input.acceptanceCriteria,
+                    amount: input.amount,
+                    currency: input.currency || 'USDC',
+                    submissionMethod: input.submissionMethod || 'pr',
+                    posterAgentId: input.posterAgentId,
+                    status: input.fundNow ? 'open' : 'draft',
+                    claims: [],
+                    createdAt: Timestamp.fromDate(now),
+                    expiresAt: Timestamp.fromDate(expiresAt),
+                    viewCount: 0,
+                    claimCount: 0,
+                };
+                // Only add optional fields if they have values
+                if (input.repoUrl)
+                    bountyData.repoUrl = input.repoUrl;
+                if (input.files?.length)
+                    bountyData.files = input.files;
+                if (input.targetBranch)
+                    bountyData.targetBranch = input.targetBranch;
+                if (input.tags?.length)
+                    bountyData.tags = input.tags;
+                if (input.modAgentId)
+                    bountyData.modAgentId = input.modAgentId;
+                // Create bounty
+                const bountyRef = await bountiesCollection().add(bountyData);
+                const bountyId = bountyRef.id;
+                // If funding, deduct balance
+                if (input.fundNow) {
+                    await debitBalance(input.posterAgentId, input.amount);
+                    await bountyRef.update({
+                        escrowId: `bounty_${bountyId}`,
+                    });
+                }
+                return {
+                    success: true,
+                    message: input.fundNow
+                        ? `Bounty created and funded! Agents can now claim it.`
+                        : `Bounty created as draft. Use bounty_fund to make it visible to agents.`,
+                    bounty: {
+                        id: bountyId,
+                        title: input.title,
+                        amount: input.amount,
+                        currency: input.currency || 'USDC',
+                        status: input.fundNow ? 'open' : 'draft',
+                        expiresAt: expiresAt.toISOString(),
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to create bounty',
+                };
+            }
+        },
+    },
+    bounty_fund: {
+        description: 'Fund a draft bounty from your balance to make it open for claims.',
+        inputSchema: bountyFundSchema,
+        handler: async (input) => {
+            try {
+                const isValid = await validateApiKey(input.agentId, input.apiKey);
+                if (!isValid) {
+                    return { success: false, error: 'Invalid API key' };
+                }
+                const bountyRef = bountiesCollection().doc(input.bountyId);
+                const bountyDoc = await bountyRef.get();
+                const bounty = docToBounty(bountyDoc);
+                if (!bounty) {
+                    return { success: false, error: 'Bounty not found' };
+                }
+                if (bounty.posterAgentId !== input.agentId) {
+                    return { success: false, error: 'Only the poster can fund this bounty' };
+                }
+                if (bounty.status !== 'draft') {
+                    return { success: false, error: `Bounty is already ${bounty.status}` };
+                }
+                const balance = await getBalance(input.agentId);
+                if (balance < bounty.amount) {
+                    return {
+                        success: false,
+                        error: `Insufficient balance. Have: ${balance}, need: ${bounty.amount}`,
+                    };
+                }
+                await debitBalance(input.agentId, bounty.amount);
+                await bountyRef.update({
+                    status: 'open',
+                    escrowId: `bounty_${bounty.id}`,
+                });
+                return {
+                    success: true,
+                    message: `Bounty funded! ${bounty.amount} ${bounty.currency} locked. Agents can now claim it.`,
+                    bounty: {
+                        id: bounty.id,
+                        title: bounty.title,
+                        status: 'open',
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to fund bounty',
+                };
+            }
+        },
+    },
+    bounty_claim: {
+        description: 'Claim a bounty to work on it. You get a 24-hour lock to submit.',
+        inputSchema: bountyClaimSchema,
+        handler: async (input) => {
+            try {
+                const isValid = await validateApiKey(input.agentId, input.apiKey);
+                if (!isValid) {
+                    return { success: false, error: 'Invalid API key' };
+                }
+                const bountyRef = bountiesCollection().doc(input.bountyId);
+                const bountyDoc = await bountyRef.get();
+                const bounty = docToBounty(bountyDoc);
+                if (!bounty) {
+                    return { success: false, error: 'Bounty not found' };
+                }
+                if (bounty.status !== 'open') {
+                    return { success: false, error: `Bounty is not open (status: ${bounty.status})` };
+                }
+                // Check for active claims that haven't expired
+                const now = new Date();
+                const activeClaim = bounty.claims.find(c => c.status === 'active' && c.expiresAt > now);
+                if (activeClaim) {
+                    const remainingMs = activeClaim.expiresAt.getTime() - now.getTime();
+                    const remainingHours = Math.ceil(remainingMs / (1000 * 60 * 60));
+                    return {
+                        success: false,
+                        error: `Bounty is currently claimed by another agent. Try again in ~${remainingHours} hours.`,
+                    };
+                }
+                // Expire any old active claims
+                const updatedClaims = bounty.claims.map(c => {
+                    if (c.status === 'active' && c.expiresAt <= now) {
+                        return { ...c, status: 'expired' };
+                    }
+                    return c;
+                });
+                const expiresAt = new Date(now.getTime() + CLAIM_LOCK_HOURS * 60 * 60 * 1000);
+                const newClaim = {
+                    agentId: input.agentId,
+                    claimedAt: now,
+                    expiresAt,
+                    status: 'active',
+                };
+                await bountyRef.update({
+                    status: 'claimed',
+                    claims: [
+                        ...updatedClaims.map(c => ({
+                            ...c,
+                            claimedAt: Timestamp.fromDate(c.claimedAt),
+                            expiresAt: Timestamp.fromDate(c.expiresAt),
+                            submittedAt: c.submittedAt ? Timestamp.fromDate(c.submittedAt) : null,
+                        })),
+                        {
+                            ...newClaim,
+                            claimedAt: Timestamp.fromDate(newClaim.claimedAt),
+                            expiresAt: Timestamp.fromDate(newClaim.expiresAt),
+                        },
+                    ],
+                    claimCount: bounty.claimCount + 1,
+                });
+                return {
+                    success: true,
+                    message: `Bounty claimed! You have ${CLAIM_LOCK_HOURS} hours to submit.`,
+                    claim: {
+                        bountyId: bounty.id,
+                        title: bounty.title,
+                        amount: bounty.amount,
+                        currency: bounty.currency,
+                        claimedAt: now.toISOString(),
+                        expiresAt: expiresAt.toISOString(),
+                        submissionMethod: bounty.submissionMethod,
+                        targetBranch: bounty.targetBranch,
+                        acceptanceCriteria: bounty.acceptanceCriteria,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to claim bounty',
+                };
+            }
+        },
+    },
+    bounty_submit: {
+        description: 'Submit your work for a claimed bounty.',
+        inputSchema: bountySubmitSchema,
+        handler: async (input) => {
+            try {
+                const isValid = await validateApiKey(input.agentId, input.apiKey);
+                if (!isValid) {
+                    return { success: false, error: 'Invalid API key' };
+                }
+                const bountyRef = bountiesCollection().doc(input.bountyId);
+                const bountyDoc = await bountyRef.get();
+                const bounty = docToBounty(bountyDoc);
+                if (!bounty) {
+                    return { success: false, error: 'Bounty not found' };
+                }
+                // Find agent's active claim
+                const claimIndex = bounty.claims.findIndex(c => c.agentId === input.agentId && c.status === 'active');
+                if (claimIndex === -1) {
+                    return { success: false, error: 'You do not have an active claim on this bounty' };
+                }
+                // Update claim with submission
+                const now = new Date();
+                const updatedClaims = [...bounty.claims];
+                updatedClaims[claimIndex] = {
+                    ...updatedClaims[claimIndex],
+                    submissionUrl: input.submissionUrl,
+                    submittedAt: now,
+                    notes: input.notes,
+                    status: 'submitted',
+                };
+                await bountyRef.update({
+                    status: 'in_review',
+                    claims: updatedClaims.map(c => ({
+                        ...c,
+                        claimedAt: Timestamp.fromDate(c.claimedAt),
+                        expiresAt: Timestamp.fromDate(c.expiresAt),
+                        submittedAt: c.submittedAt ? Timestamp.fromDate(c.submittedAt) : null,
+                    })),
+                });
+                return {
+                    success: true,
+                    message: 'Submission received! Awaiting moderator review.',
+                    submission: {
+                        bountyId: bounty.id,
+                        title: bounty.title,
+                        submissionUrl: input.submissionUrl,
+                        status: 'in_review',
+                        modAgentId: bounty.modAgentId || bounty.posterAgentId,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to submit',
+                };
+            }
+        },
+    },
+    bounty_judge: {
+        description: 'Judge a bounty submission and crown the winner. Only the poster or mod agent can judge.',
+        inputSchema: bountyJudgeSchema,
+        handler: async (input) => {
+            try {
+                const isValid = await validateApiKey(input.judgeAgentId, input.apiKey);
+                if (!isValid) {
+                    return { success: false, error: 'Invalid API key' };
+                }
+                const bountyRef = bountiesCollection().doc(input.bountyId);
+                const bountyDoc = await bountyRef.get();
+                const bounty = docToBounty(bountyDoc);
+                if (!bounty) {
+                    return { success: false, error: 'Bounty not found' };
+                }
+                // Check authorization
+                const isAuthorized = input.judgeAgentId === bounty.posterAgentId ||
+                    input.judgeAgentId === bounty.modAgentId;
+                if (!isAuthorized) {
+                    return { success: false, error: 'Only the poster or mod agent can judge' };
+                }
+                if (bounty.status !== 'in_review') {
+                    return { success: false, error: `Bounty is not in review (status: ${bounty.status})` };
+                }
+                // Find winner's submission
+                const winnerClaim = bounty.claims.find(c => c.agentId === input.winnerAgentId && c.status === 'submitted');
+                if (!winnerClaim) {
+                    return { success: false, error: 'Winner has no submitted claim' };
+                }
+                // Pay the winner (full amount - platform takes fee on deposit, not bounty)
+                await creditBalance(input.winnerAgentId, bounty.amount);
+                // Update bounty
+                const now = new Date();
+                await bountyRef.update({
+                    status: 'completed',
+                    winnerAgentId: input.winnerAgentId,
+                    winnerSubmissionUrl: winnerClaim.submissionUrl,
+                    completedAt: Timestamp.fromDate(now),
+                });
+                return {
+                    success: true,
+                    message: `Winner crowned! ${bounty.amount} ${bounty.currency} paid to ${input.winnerAgentId}`,
+                    result: {
+                        bountyId: bounty.id,
+                        title: bounty.title,
+                        winnerAgentId: input.winnerAgentId,
+                        winnerSubmissionUrl: winnerClaim.submissionUrl,
+                        amount: bounty.amount,
+                        currency: bounty.currency,
+                        judgingNotes: input.notes,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to judge bounty',
+                };
+            }
+        },
+    },
+    bounty_search: {
+        description: 'Search for open bounties to claim. Filter by skill, difficulty, or reward amount.',
+        inputSchema: bountySearchSchema,
+        handler: async (input) => {
+            try {
+                const status = input.status || 'open';
+                let query = bountiesCollection().where('status', '==', status);
+                if (input.difficulty) {
+                    query = query.where('difficulty', '==', input.difficulty);
+                }
+                const snapshot = await query.limit((input.limit || 20) * 2).get(); // Fetch extra for client-side filtering
+                let bounties = snapshot.docs.map(doc => {
+                    const data = doc.data();
+                    return {
+                        id: doc.id,
+                        title: data.title,
+                        summary: data.summary,
+                        amount: data.amount,
+                        currency: data.currency,
+                        difficulty: data.difficulty,
+                        requiredSkills: data.requiredSkills || [],
+                        status: data.status,
+                        expiresAt: data.expiresAt?.toDate() || new Date(),
+                        claimCount: data.claimCount || 0,
+                        posterAgentId: data.posterAgentId,
+                    };
+                });
+                // Client-side filtering for complex queries
+                if (input.skill) {
+                    const skillLower = input.skill.toLowerCase();
+                    bounties = bounties.filter(b => b.requiredSkills.some(s => s.toLowerCase().includes(skillLower)));
+                }
+                if (input.minAmount !== undefined) {
+                    bounties = bounties.filter(b => b.amount >= input.minAmount);
+                }
+                if (input.maxAmount !== undefined) {
+                    bounties = bounties.filter(b => b.amount <= input.maxAmount);
+                }
+                if (input.tag) {
+                    // Would need to add tags to the query or filter
+                }
+                // Sort by amount descending, limit results
+                bounties = bounties
+                    .sort((a, b) => b.amount - a.amount)
+                    .slice(0, input.limit || 20);
+                return {
+                    success: true,
+                    bounties,
+                    count: bounties.length,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to search bounties',
+                    bounties: [],
+                    count: 0,
+                };
+            }
+        },
+    },
+    bounty_get: {
+        description: 'Get full details of a bounty including the task description and acceptance criteria.',
+        inputSchema: bountyGetSchema,
+        handler: async (input) => {
+            try {
+                const bountyDoc = await bountiesCollection().doc(input.bountyId).get();
+                const bounty = docToBounty(bountyDoc);
+                if (!bounty) {
+                    return { success: false, error: 'Bounty not found' };
+                }
+                // Increment view count (fire and forget)
+                bountiesCollection().doc(input.bountyId).update({
+                    viewCount: (bounty.viewCount || 0) + 1,
+                }).catch(() => { }); // Ignore errors
+                return {
+                    success: true,
+                    bounty: {
+                        ...bounty,
+                        createdAt: bounty.createdAt.toISOString(),
+                        expiresAt: bounty.expiresAt.toISOString(),
+                        completedAt: bounty.completedAt?.toISOString(),
+                        // Simplify claims for output
+                        claims: bounty.claims.map(c => ({
+                            agentId: c.agentId,
+                            status: c.status,
+                            submittedAt: c.submittedAt?.toISOString(),
+                            submissionUrl: c.status === 'submitted' ? c.submissionUrl : undefined,
+                        })),
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to get bounty',
+                };
+            }
+        },
+    },
+    bounty_export_markdown: {
+        description: 'Export a bounty as a markdown file for sharing or publishing.',
+        inputSchema: bountyExportMarkdownSchema,
+        handler: async (input) => {
+            try {
+                const bountyDoc = await bountiesCollection().doc(input.bountyId).get();
+                const bounty = docToBounty(bountyDoc);
+                if (!bounty) {
+                    return { success: false, error: 'Bounty not found' };
+                }
+                const markdown = bountyToMarkdown(bounty);
+                return {
+                    success: true,
+                    bountyId: bounty.id,
+                    title: bounty.title,
+                    filename: `bounty-${bounty.id}.md`,
+                    markdown,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to export bounty',
+                };
+            }
+        },
+    },
+};

package/dist/tools/index.d.ts

@@ -2,3 +2,4 @@ export { escrowTools } from './escrow.js';
 export { agentTools } from './agent.js';
 export { adminTools } from './admin.js';
 export { paymentTools } from './payment.js';
+export { bountyTools } from './bounty.js';

package/dist/tools/index.js

@@ -2,3 +2,4 @@ export { escrowTools } from './escrow.js';
 export { agentTools } from './agent.js';
 export { adminTools } from './admin.js';
 export { paymentTools } from './payment.js';
+export { bountyTools } from './bounty.js';

package/dist/types/index.d.ts

@@ -46,6 +46,8 @@ export interface Agent {
     balance: number;
     nostrPubkey?: string;
     nip05?: string;
+    moltbookId?: string;
+    moltbookKarma?: number;
     wallets?: {
         base?: string;
         trc20?: string;
@@ -84,3 +86,60 @@ export interface Task {
     completedAt: Date | null;
     result: string | null;
 }
+export type BountyStatus = 'draft' | 'open' | 'claimed' | 'in_review' | 'completed' | 'expired' | 'cancelled';
+export type BountyDifficulty = 'trivial' | 'easy' | 'medium' | 'hard' | 'expert';
+export type SubmissionMethod = 'pr' | 'patch' | 'gist' | 'proof';
+export interface BountyFile {
+    path: string;
+    description?: string;
+}
+export interface BountyClaim {
+    agentId: string;
+    claimedAt: Date;
+    expiresAt: Date;
+    submissionUrl?: string;
+    submittedAt?: Date;
+    notes?: string;
+    status: 'active' | 'submitted' | 'expired' | 'withdrawn';
+}
+export interface Bounty {
+    id: string;
+    title: string;
+    description: string;
+    summary: string;
+    difficulty: BountyDifficulty;
+    requiredSkills: string[];
+    tags?: string[];
+    repoUrl?: string;
+    files?: BountyFile[];
+    acceptanceCriteria: string[];
+    submissionMethod: SubmissionMethod;
+    targetBranch?: string;
+    amount: number;
+    currency: Currency;
+    escrowId?: string;
+    createdAt: Date;
+    expiresAt: Date;
+    completedAt?: Date;
+    posterAgentId: string;
+    modAgentId?: string;
+    status: BountyStatus;
+    claims: BountyClaim[];
+    winnerAgentId?: string;
+    winnerSubmissionUrl?: string;
+    viewCount: number;
+    claimCount: number;
+}
+export interface BountyListing {
+    id: string;
+    title: string;
+    summary: string;
+    amount: number;
+    currency: Currency;
+    difficulty: BountyDifficulty;
+    requiredSkills: string[];
+    status: BountyStatus;
+    expiresAt: Date;
+    claimCount: number;
+    posterAgentId: string;
+}