clawdentials-mcp 0.7.2 → 0.8.0

package/dist/services/moltbook.js

@@ -0,0 +1,90 @@
+/**
+ * Moltbook Identity Verification Service
+ *
+ * Verifies Moltbook identity tokens and retrieves agent profiles.
+ * See: https://www.moltbook.com/developers
+ */
+const MOLTBOOK_API_BASE = 'https://www.moltbook.com/api/v1';
+// App key for verifying identity tokens (set via environment)
+const MOLTBOOK_APP_KEY = process.env.MOLTBOOK_APP_KEY || '';
+/**
+ * Verify a Moltbook identity token and retrieve the agent's profile.
+ *
+ * @param identityToken - The JWT identity token from the agent
+ * @returns The verified agent profile or an error
+ */
+export async function verifyMoltbookIdentity(identityToken) {
+    if (!MOLTBOOK_APP_KEY) {
+        return {
+            success: false,
+            error: 'Moltbook integration not configured (missing MOLTBOOK_APP_KEY)',
+        };
+    }
+    try {
+        const response = await fetch(`${MOLTBOOK_API_BASE}/agents/verify-identity`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Moltbook-App-Key': MOLTBOOK_APP_KEY,
+            },
+            body: JSON.stringify({ token: identityToken }),
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                return {
+                    success: false,
+                    error: 'Invalid or expired Moltbook identity token',
+                };
+            }
+            return {
+                success: false,
+                error: `Moltbook verification failed: ${response.status}`,
+            };
+        }
+        const data = await response.json();
+        return {
+            success: true,
+            agent: {
+                id: data.id,
+                name: data.name,
+                description: data.description,
+                karma: data.karma || 0,
+                avatar_url: data.avatar_url,
+                claimed: data.claimed || false,
+                created_at: data.created_at,
+                follower_count: data.follower_count || 0,
+                post_count: data.post_count || 0,
+                comment_count: data.comment_count || 0,
+                owner_x_handle: data.owner_x_handle,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to verify Moltbook identity',
+        };
+    }
+}
+/**
+ * Convert Moltbook karma to an initial Clawdentials reputation boost.
+ *
+ * Karma on Moltbook is unbounded, so we use a log scale to convert
+ * to a reasonable starting boost (0-20 points on the reputation score).
+ *
+ * @param karma - The agent's Moltbook karma
+ * @returns Initial reputation boost (0-20)
+ */
+export function karmaToReputationBoost(karma) {
+    if (karma <= 0)
+        return 0;
+    // Log scale: 1 karma = 0, 10 karma = ~7, 100 karma = ~14, 1000 karma = ~20
+    const boost = Math.log10(karma + 1) * 7;
+    return Math.min(20, Math.round(boost * 10) / 10);
+}
+/**
+ * Check if Moltbook integration is configured.
+ */
+export function isMoltbookConfigured() {
+    return !!MOLTBOOK_APP_KEY;
+}

package/dist/tools/agent.d.ts

@@ -6,16 +6,25 @@ export declare const agentTools: {
             name: import("zod").ZodString;
             description: import("zod").ZodString;
             skills: import("zod").ZodArray<import("zod").ZodString, "many">;
+            moltbookToken: import("zod").ZodOptional<import("zod").ZodString>;
         }, "strip", import("zod").ZodTypeAny, {
             name: string;
             description: string;
             skills: string[];
+            moltbookToken?: string | undefined;
         }, {
             name: string;
             description: string;
             skills: string[];
+            moltbookToken?: string | undefined;
         }>;
         handler: (input: AgentRegisterInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            credentials?: undefined;
+            agent?: undefined;
+        } | {
             success: boolean;
             message: string;
             credentials: {
@@ -35,17 +44,14 @@ export declare const agentTools: {
                 subscriptionTier: import("../types/index.js").SubscriptionTier;
                 balance: number;
                 nip05: string | undefined;
+                moltbookId: string | undefined;
+                moltbookKarma: number | undefined;
                 createdAt: string;
                 stats: import("../types/index.js").AgentStats;
                 reputationScore: number;
+                reputationBoost: number | undefined;
             };
             error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            message?: undefined;
-            credentials?: undefined;
-            agent?: undefined;
         }>;
     };
     agent_score: {
@@ -79,6 +85,11 @@ export declare const agentTools: {
                     avgCompletionTime: number;
                 };
                 accountAgeDays: number;
+                moltbook: {
+                    id: string;
+                    karma: number | undefined;
+                    reputationBoost: number;
+                } | undefined;
             };
             error?: undefined;
         }>;

package/dist/tools/agent.js

@@ -1,21 +1,49 @@
 import { agentRegisterSchema, agentScoreSchema, agentSearchSchema, agentBalanceSchema, withdrawRequestSchema, } from '../schemas/index.js';
 import { createAgent, getAgent, searchAgents, calculateReputationScore, validateApiKey, getBalance, createWithdrawal, } from '../services/firestore.js';
+import { verifyMoltbookIdentity, karmaToReputationBoost, isMoltbookConfigured, } from '../services/moltbook.js';
 export const agentTools = {
     agent_register: {
-        description: 'Register as an agent on Clawdentials. Returns an API key and Nostr identity (NIP-05) - SAVE BOTH SECURELY, they cannot be recovered!',
+        description: 'Register as an agent on Clawdentials. Optionally link your Moltbook account to import karma. Returns an API key and Nostr identity (NIP-05) - SAVE BOTH SECURELY, they cannot be recovered!',
         inputSchema: agentRegisterSchema,
         handler: async (input) => {
             try {
+                // Verify Moltbook identity if token provided
+                let moltbookData;
+                let reputationBoost = 0;
+                if (input.moltbookToken) {
+                    if (!isMoltbookConfigured()) {
+                        return {
+                            success: false,
+                            error: 'Moltbook integration is not configured on this server. Register without moltbookToken or contact admin.',
+                        };
+                    }
+                    const moltbookResult = await verifyMoltbookIdentity(input.moltbookToken);
+                    if (!moltbookResult.success || !moltbookResult.agent) {
+                        return {
+                            success: false,
+                            error: moltbookResult.error || 'Failed to verify Moltbook identity',
+                        };
+                    }
+                    moltbookData = {
+                        id: moltbookResult.agent.id,
+                        karma: moltbookResult.agent.karma,
+                    };
+                    reputationBoost = karmaToReputationBoost(moltbookResult.agent.karma);
+                }
                 const { agent, apiKey, nostr } = await createAgent({
                     name: input.name,
                     description: input.description,
                     skills: input.skills,
                     verified: false,
                     subscriptionTier: 'free',
+                    moltbookId: moltbookData?.id,
+                    moltbookKarma: moltbookData?.karma,
                 });
+                const baseScore = calculateReputationScore(agent);
+                const finalScore = Math.min(100, baseScore + reputationBoost);
                 return {
                     success: true,
-                    message: `Agent "${input.name}" registered successfully. SAVE YOUR CREDENTIALS - they cannot be recovered!`,
+                    message: `Agent "${input.name}" registered successfully.${moltbookData ? ` Moltbook linked (karma: ${moltbookData.karma}, reputation boost: +${reputationBoost}).` : ''} SAVE YOUR CREDENTIALS - they cannot be recovered!`,
                     credentials: {
                         apiKey, // Only returned once!
                         nostr: {
@@ -33,9 +61,12 @@ export const agentTools = {
                         subscriptionTier: agent.subscriptionTier,
                         balance: agent.balance,
                         nip05: agent.nip05,
+                        moltbookId: agent.moltbookId,
+                        moltbookKarma: agent.moltbookKarma,
                         createdAt: agent.createdAt.toISOString(),
                         stats: agent.stats,
-                        reputationScore: calculateReputationScore(agent),
+                        reputationScore: finalScore,
+                        reputationBoost: reputationBoost > 0 ? reputationBoost : undefined,
                     },
                 };
             }
@@ -69,6 +100,8 @@ export const agentTools = {
             const badges = [];
             if (agent.verified)
                 badges.push('Verified');
+            if (agent.moltbookId)
+                badges.push('Moltbook Linked');
             if (agent.stats.tasksCompleted >= 100)
                 badges.push('Experienced');
             if (agent.stats.tasksCompleted >= 1000)
@@ -77,12 +110,15 @@ export const agentTools = {
                 badges.push('Reliable');
             if (reputationScore >= 80)
                 badges.push('Top Performer');
+            // Calculate Moltbook reputation boost if applicable
+            const moltbookBoost = agent.moltbookKarma ? karmaToReputationBoost(agent.moltbookKarma) : 0;
+            const finalScore = Math.min(100, reputationScore + moltbookBoost);
             return {
                 success: true,
                 agent: {
                     id: agent.id,
                     name: agent.name,
-                    reputationScore,
+                    reputationScore: finalScore,
                     badges,
                     verified: agent.verified,
                     subscriptionTier: agent.subscriptionTier,
@@ -95,6 +131,11 @@ export const agentTools = {
                         avgCompletionTime: agent.stats.avgCompletionTime,
                     },
                     accountAgeDays: Math.floor((Date.now() - agent.createdAt.getTime()) / (1000 * 60 * 60 * 24)),
+                    moltbook: agent.moltbookId ? {
+                        id: agent.moltbookId,
+                        karma: agent.moltbookKarma,
+                        reputationBoost: moltbookBoost,
+                    } : undefined,
                 },
             };
         },

package/dist/tools/bounty.d.ts

@@ -0,0 +1,361 @@
+import { type BountyCreateInput, type BountyFundInput, type BountyClaimInput, type BountySubmitInput, type BountyJudgeInput, type BountySearchInput, type BountyGetInput, type BountyExportMarkdownInput } from '../schemas/index.js';
+import type { BountyListing } from '../types/index.js';
+export declare const bountyTools: {
+    bounty_create: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            title: import("zod").ZodString;
+            summary: import("zod").ZodString;
+            description: import("zod").ZodString;
+            difficulty: import("zod").ZodEnum<["trivial", "easy", "medium", "hard", "expert"]>;
+            requiredSkills: import("zod").ZodArray<import("zod").ZodString, "many">;
+            acceptanceCriteria: import("zod").ZodArray<import("zod").ZodString, "many">;
+            amount: import("zod").ZodNumber;
+            currency: import("zod").ZodDefault<import("zod").ZodEnum<["USD", "USDC", "USDT", "BTC"]>>;
+            expiresInDays: import("zod").ZodDefault<import("zod").ZodNumber>;
+            repoUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                path: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                path: string;
+                description?: string | undefined;
+            }, {
+                path: string;
+                description?: string | undefined;
+            }>, "many">>;
+            submissionMethod: import("zod").ZodDefault<import("zod").ZodEnum<["pr", "patch", "gist", "proof"]>>;
+            targetBranch: import("zod").ZodOptional<import("zod").ZodString>;
+            modAgentId: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            posterAgentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+            fundNow: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        }, "strip", import("zod").ZodTypeAny, {
+            amount: number;
+            currency: "USD" | "USDC" | "BTC" | "USDT";
+            apiKey: string;
+            description: string;
+            title: string;
+            summary: string;
+            difficulty: "trivial" | "easy" | "medium" | "hard" | "expert";
+            requiredSkills: string[];
+            acceptanceCriteria: string[];
+            expiresInDays: number;
+            submissionMethod: "pr" | "patch" | "gist" | "proof";
+            posterAgentId: string;
+            fundNow: boolean;
+            repoUrl?: string | undefined;
+            files?: {
+                path: string;
+                description?: string | undefined;
+            }[] | undefined;
+            targetBranch?: string | undefined;
+            modAgentId?: string | undefined;
+            tags?: string[] | undefined;
+        }, {
+            amount: number;
+            apiKey: string;
+            description: string;
+            title: string;
+            summary: string;
+            difficulty: "trivial" | "easy" | "medium" | "hard" | "expert";
+            requiredSkills: string[];
+            acceptanceCriteria: string[];
+            posterAgentId: string;
+            currency?: "USD" | "USDC" | "BTC" | "USDT" | undefined;
+            expiresInDays?: number | undefined;
+            repoUrl?: string | undefined;
+            files?: {
+                path: string;
+                description?: string | undefined;
+            }[] | undefined;
+            submissionMethod?: "pr" | "patch" | "gist" | "proof" | undefined;
+            targetBranch?: string | undefined;
+            modAgentId?: string | undefined;
+            tags?: string[] | undefined;
+            fundNow?: boolean | undefined;
+        }>;
+        handler: (input: BountyCreateInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            bounty?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            bounty: {
+                id: string;
+                title: string;
+                amount: number;
+                currency: "USD" | "USDC" | "BTC" | "USDT";
+                status: string;
+                expiresAt: string;
+            };
+            error?: undefined;
+        }>;
+    };
+    bounty_fund: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            bountyId: import("zod").ZodString;
+            agentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
+            agentId: string;
+            bountyId: string;
+        }, {
+            apiKey: string;
+            agentId: string;
+            bountyId: string;
+        }>;
+        handler: (input: BountyFundInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            bounty?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            bounty: {
+                id: string;
+                title: string;
+                status: string;
+            };
+            error?: undefined;
+        }>;
+    };
+    bounty_claim: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            bountyId: import("zod").ZodString;
+            agentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
+            agentId: string;
+            bountyId: string;
+        }, {
+            apiKey: string;
+            agentId: string;
+            bountyId: string;
+        }>;
+        handler: (input: BountyClaimInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            claim?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            claim: {
+                bountyId: string;
+                title: string;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+                claimedAt: string;
+                expiresAt: string;
+                submissionMethod: import("../types/index.js").SubmissionMethod;
+                targetBranch: string | undefined;
+                acceptanceCriteria: string[];
+            };
+            error?: undefined;
+        }>;
+    };
+    bounty_submit: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            bountyId: import("zod").ZodString;
+            submissionUrl: import("zod").ZodString;
+            notes: import("zod").ZodOptional<import("zod").ZodString>;
+            agentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
+            agentId: string;
+            bountyId: string;
+            submissionUrl: string;
+            notes?: string | undefined;
+        }, {
+            apiKey: string;
+            agentId: string;
+            bountyId: string;
+            submissionUrl: string;
+            notes?: string | undefined;
+        }>;
+        handler: (input: BountySubmitInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            submission?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            submission: {
+                bountyId: string;
+                title: string;
+                submissionUrl: string;
+                status: string;
+                modAgentId: string;
+            };
+            error?: undefined;
+        }>;
+    };
+    bounty_judge: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            bountyId: import("zod").ZodString;
+            winnerAgentId: import("zod").ZodString;
+            notes: import("zod").ZodOptional<import("zod").ZodString>;
+            judgeAgentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
+            bountyId: string;
+            winnerAgentId: string;
+            judgeAgentId: string;
+            notes?: string | undefined;
+        }, {
+            apiKey: string;
+            bountyId: string;
+            winnerAgentId: string;
+            judgeAgentId: string;
+            notes?: string | undefined;
+        }>;
+        handler: (input: BountyJudgeInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            result?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            result: {
+                bountyId: string;
+                title: string;
+                winnerAgentId: string;
+                winnerSubmissionUrl: string | undefined;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+                judgingNotes: string | undefined;
+            };
+            error?: undefined;
+        }>;
+    };
+    bounty_search: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            skill: import("zod").ZodOptional<import("zod").ZodString>;
+            difficulty: import("zod").ZodOptional<import("zod").ZodEnum<["trivial", "easy", "medium", "hard", "expert"]>>;
+            status: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["open", "claimed", "in_review"]>>>;
+            minAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+            maxAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+            tag: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            status: "open" | "claimed" | "in_review";
+            limit: number;
+            skill?: string | undefined;
+            difficulty?: "trivial" | "easy" | "medium" | "hard" | "expert" | undefined;
+            minAmount?: number | undefined;
+            maxAmount?: number | undefined;
+            tag?: string | undefined;
+        }, {
+            status?: "open" | "claimed" | "in_review" | undefined;
+            skill?: string | undefined;
+            limit?: number | undefined;
+            difficulty?: "trivial" | "easy" | "medium" | "hard" | "expert" | undefined;
+            minAmount?: number | undefined;
+            maxAmount?: number | undefined;
+            tag?: string | undefined;
+        }>;
+        handler: (input: BountySearchInput) => Promise<{
+            success: boolean;
+            bounties: BountyListing[];
+            count: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            bounties: never[];
+            count: number;
+        }>;
+    };
+    bounty_get: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            bountyId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            bountyId: string;
+        }, {
+            bountyId: string;
+        }>;
+        handler: (input: BountyGetInput) => Promise<{
+            success: boolean;
+            error: string;
+            bounty?: undefined;
+        } | {
+            success: boolean;
+            bounty: {
+                createdAt: string;
+                expiresAt: string;
+                completedAt: string | undefined;
+                claims: {
+                    agentId: string;
+                    status: "expired" | "active" | "submitted" | "withdrawn";
+                    submittedAt: string | undefined;
+                    submissionUrl: string | undefined;
+                }[];
+                id: string;
+                title: string;
+                description: string;
+                summary: string;
+                difficulty: import("../types/index.js").BountyDifficulty;
+                requiredSkills: string[];
+                tags?: string[];
+                repoUrl?: string;
+                files?: import("../types/index.js").BountyFile[];
+                acceptanceCriteria: string[];
+                submissionMethod: import("../types/index.js").SubmissionMethod;
+                targetBranch?: string;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+                escrowId?: string;
+                posterAgentId: string;
+                modAgentId?: string;
+                status: import("../types/index.js").BountyStatus;
+                winnerAgentId?: string;
+                winnerSubmissionUrl?: string;
+                viewCount: number;
+                claimCount: number;
+            };
+            error?: undefined;
+        }>;
+    };
+    bounty_export_markdown: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            bountyId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            bountyId: string;
+        }, {
+            bountyId: string;
+        }>;
+        handler: (input: BountyExportMarkdownInput) => Promise<{
+            success: boolean;
+            error: string;
+            bountyId?: undefined;
+            title?: undefined;
+            filename?: undefined;
+            markdown?: undefined;
+        } | {
+            success: boolean;
+            bountyId: string;
+            title: string;
+            filename: string;
+            markdown: string;
+            error?: undefined;
+        }>;
+    };
+};