clawdentials-mcp 0.1.0 → 0.7.2

package/dist/tools/admin.js

@@ -0,0 +1,210 @@
+import { adminCreditBalanceSchema, adminProcessWithdrawalSchema, adminListWithdrawalsSchema, } from '../schemas/index.js';
+import { ADMIN_SECRET, creditBalance, getBalance, getAgent, processWithdrawal, listWithdrawals, refundEscrow, getEscrow, collections, } from '../services/firestore.js';
+import { z } from 'zod';
+// Admin refund schema
+const adminRefundSchema = z.object({
+    adminSecret: z.string().min(1).describe('Admin secret key'),
+    escrowId: z.string().min(1).describe('ID of the disputed escrow to refund'),
+});
+export const adminTools = {
+    admin_credit_balance: {
+        description: 'Credit funds to an agent\'s balance after receiving manual payment (PayPal/Venmo).',
+        inputSchema: adminCreditBalanceSchema,
+        handler: async (input) => {
+            // Validate admin secret
+            if (input.adminSecret !== ADMIN_SECRET) {
+                return {
+                    success: false,
+                    error: 'Invalid admin secret',
+                };
+            }
+            // Check agent exists
+            const agent = await getAgent(input.agentId);
+            if (!agent) {
+                return {
+                    success: false,
+                    error: `Agent not found: ${input.agentId}`,
+                };
+            }
+            const oldBalance = await getBalance(input.agentId);
+            const newBalance = await creditBalance(input.agentId, input.amount, input.notes);
+            return {
+                success: true,
+                message: `Credited ${input.amount} ${input.currency} to ${input.agentId}`,
+                agentId: input.agentId,
+                oldBalance,
+                credited: input.amount,
+                newBalance,
+                currency: input.currency,
+                notes: input.notes,
+            };
+        },
+    },
+    admin_list_withdrawals: {
+        description: 'List pending withdrawal requests.',
+        inputSchema: adminListWithdrawalsSchema,
+        handler: async (input) => {
+            // Validate admin secret
+            if (input.adminSecret !== ADMIN_SECRET) {
+                return {
+                    success: false,
+                    error: 'Invalid admin secret',
+                };
+            }
+            const withdrawals = await listWithdrawals(input.status, input.limit);
+            return {
+                success: true,
+                withdrawals: withdrawals.map(w => ({
+                    id: w.id,
+                    agentId: w.agentId,
+                    amount: w.amount,
+                    currency: w.currency,
+                    status: w.status,
+                    paymentMethod: w.paymentMethod,
+                    requestedAt: w.requestedAt.toISOString(),
+                    processedAt: w.processedAt?.toISOString() ?? null,
+                    notes: w.notes,
+                })),
+                count: withdrawals.length,
+            };
+        },
+    },
+    admin_process_withdrawal: {
+        description: 'Process a withdrawal request - mark as completed (after sending payment) or rejected.',
+        inputSchema: adminProcessWithdrawalSchema,
+        handler: async (input) => {
+            // Validate admin secret
+            if (input.adminSecret !== ADMIN_SECRET) {
+                return {
+                    success: false,
+                    error: 'Invalid admin secret',
+                };
+            }
+            try {
+                const withdrawal = await processWithdrawal(input.withdrawalId, input.action, input.notes);
+                if (!withdrawal) {
+                    return {
+                        success: false,
+                        error: `Withdrawal not found: ${input.withdrawalId}`,
+                    };
+                }
+                const actionText = input.action === 'complete' ? 'completed' : 'rejected';
+                return {
+                    success: true,
+                    message: `Withdrawal ${actionText}`,
+                    withdrawal: {
+                        id: withdrawal.id,
+                        agentId: withdrawal.agentId,
+                        amount: withdrawal.amount,
+                        currency: withdrawal.currency,
+                        status: withdrawal.status,
+                        paymentMethod: withdrawal.paymentMethod,
+                        processedAt: withdrawal.processedAt?.toISOString(),
+                        notes: withdrawal.notes,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to process withdrawal',
+                };
+            }
+        },
+    },
+    admin_refund_escrow: {
+        description: 'Refund a disputed escrow back to the client.',
+        inputSchema: adminRefundSchema,
+        handler: async (input) => {
+            // Validate admin secret
+            if (input.adminSecret !== ADMIN_SECRET) {
+                return {
+                    success: false,
+                    error: 'Invalid admin secret',
+                };
+            }
+            const existingEscrow = await getEscrow(input.escrowId);
+            if (!existingEscrow) {
+                return {
+                    success: false,
+                    error: `Escrow not found: ${input.escrowId}`,
+                };
+            }
+            if (existingEscrow.status !== 'disputed') {
+                return {
+                    success: false,
+                    error: `Can only refund disputed escrows. Current status: ${existingEscrow.status}`,
+                };
+            }
+            try {
+                const escrow = await refundEscrow(input.escrowId);
+                const newBalance = await getBalance(existingEscrow.clientAgentId);
+                return {
+                    success: true,
+                    message: `Refunded ${existingEscrow.amount} ${existingEscrow.currency} to ${existingEscrow.clientAgentId}`,
+                    escrow: {
+                        id: escrow.id,
+                        status: escrow.status,
+                        amount: existingEscrow.amount,
+                        currency: existingEscrow.currency,
+                    },
+                    clientNewBalance: newBalance,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to refund escrow',
+                };
+            }
+        },
+    },
+    admin_nostr_json: {
+        description: 'Generate the NIP-05 nostr.json file content for all registered agents. Host this at clawdentials.com/.well-known/nostr.json',
+        inputSchema: z.object({
+            adminSecret: z.string().min(1).describe('Admin secret key'),
+        }),
+        handler: async (input) => {
+            // Validate admin secret
+            if (input.adminSecret !== ADMIN_SECRET) {
+                return {
+                    success: false,
+                    error: 'Invalid admin secret',
+                };
+            }
+            try {
+                // Get all agents with Nostr pubkeys
+                const snapshot = await collections.agents().get();
+                const names = {};
+                for (const doc of snapshot.docs) {
+                    const data = doc.data();
+                    if (data.nostrPubkey) {
+                        // Use the agent name (lowercase, sanitized) as the identifier
+                        const identifier = doc.id.toLowerCase().replace(/[^a-z0-9-_.]/g, '');
+                        names[identifier] = data.nostrPubkey;
+                    }
+                }
+                // Generate the nostr.json content
+                const nostrJson = {
+                    names,
+                    // Optional: add relay hints
+                    // relays: {}
+                };
+                return {
+                    success: true,
+                    message: 'Host this JSON at: https://clawdentials.com/.well-known/nostr.json',
+                    agentCount: Object.keys(names).length,
+                    nostrJson,
+                    // Also return as string for easy copy-paste
+                    nostrJsonString: JSON.stringify(nostrJson, null, 2),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to generate nostr.json',
+                };
+            }
+        },
+    },
+};

package/dist/tools/agent.d.ts

@@ -0,0 +1,197 @@
+import { type AgentRegisterInput, type AgentScoreInput, type AgentSearchInput, type AgentBalanceInput, type WithdrawRequestInput } from '../schemas/index.js';
+export declare const agentTools: {
+    agent_register: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            skills: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            description: string;
+            skills: string[];
+        }, {
+            name: string;
+            description: string;
+            skills: string[];
+        }>;
+        handler: (input: AgentRegisterInput) => Promise<{
+            success: boolean;
+            message: string;
+            credentials: {
+                apiKey: string;
+                nostr: {
+                    nsec: string;
+                    npub: string;
+                    nip05: string;
+                };
+            };
+            agent: {
+                id: string;
+                name: string;
+                description: string;
+                skills: string[];
+                verified: boolean;
+                subscriptionTier: import("../types/index.js").SubscriptionTier;
+                balance: number;
+                nip05: string | undefined;
+                createdAt: string;
+                stats: import("../types/index.js").AgentStats;
+                reputationScore: number;
+            };
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            message?: undefined;
+            credentials?: undefined;
+            agent?: undefined;
+        }>;
+    };
+    agent_score: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            agentId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            agentId: string;
+        }, {
+            agentId: string;
+        }>;
+        handler: (input: AgentScoreInput) => Promise<{
+            success: boolean;
+            error: string;
+            agent?: undefined;
+        } | {
+            success: boolean;
+            agent: {
+                id: string;
+                name: string;
+                reputationScore: number;
+                badges: string[];
+                verified: boolean;
+                subscriptionTier: import("../types/index.js").SubscriptionTier;
+                stats: {
+                    tasksCompleted: number;
+                    totalEarned: number;
+                    successRate: number;
+                    disputeCount: number;
+                    disputeRate: number;
+                    avgCompletionTime: number;
+                };
+                accountAgeDays: number;
+            };
+            error?: undefined;
+        }>;
+    };
+    agent_search: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            skill: import("zod").ZodOptional<import("zod").ZodString>;
+            verified: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            minTasksCompleted: import("zod").ZodOptional<import("zod").ZodNumber>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            limit: number;
+            skill?: string | undefined;
+            verified?: boolean | undefined;
+            minTasksCompleted?: number | undefined;
+        }, {
+            skill?: string | undefined;
+            verified?: boolean | undefined;
+            minTasksCompleted?: number | undefined;
+            limit?: number | undefined;
+        }>;
+        handler: (input: AgentSearchInput) => Promise<{
+            success: boolean;
+            message: string;
+            agents: never[];
+            count: number;
+        } | {
+            success: boolean;
+            agents: {
+                id: string;
+                name: string;
+                description: string;
+                skills: string[];
+                verified: boolean;
+                subscriptionTier: import("../types/index.js").SubscriptionTier;
+                reputationScore: number;
+                stats: {
+                    tasksCompleted: number;
+                    totalEarned: number;
+                    disputeRate: number;
+                };
+            }[];
+            count: number;
+            message?: undefined;
+        }>;
+    };
+    agent_balance: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            agentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
+            agentId: string;
+        }, {
+            apiKey: string;
+            agentId: string;
+        }>;
+        handler: (input: AgentBalanceInput) => Promise<{
+            success: boolean;
+            error: string;
+            agentId?: undefined;
+            balance?: undefined;
+            currency?: undefined;
+            totalEarned?: undefined;
+        } | {
+            success: boolean;
+            agentId: string;
+            balance: number;
+            currency: string;
+            totalEarned: number;
+            error?: undefined;
+        }>;
+    };
+    withdraw_request: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            agentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+            amount: import("zod").ZodNumber;
+            currency: import("zod").ZodDefault<import("zod").ZodEnum<["USD", "USDC", "BTC"]>>;
+            paymentMethod: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            amount: number;
+            currency: "USD" | "USDC" | "BTC";
+            apiKey: string;
+            agentId: string;
+            paymentMethod: string;
+        }, {
+            amount: number;
+            apiKey: string;
+            agentId: string;
+            paymentMethod: string;
+            currency?: "USD" | "USDC" | "BTC" | undefined;
+        }>;
+        handler: (input: WithdrawRequestInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            withdrawal?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            withdrawal: {
+                id: string;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+                status: import("../types/index.js").WithdrawalStatus;
+                paymentMethod: string;
+                requestedAt: string;
+            };
+            error?: undefined;
+        }>;
+    };
+};

package/dist/tools/agent.js

@@ -0,0 +1,200 @@
+import { agentRegisterSchema, agentScoreSchema, agentSearchSchema, agentBalanceSchema, withdrawRequestSchema, } from '../schemas/index.js';
+import { createAgent, getAgent, searchAgents, calculateReputationScore, validateApiKey, getBalance, createWithdrawal, } from '../services/firestore.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!',
+        inputSchema: agentRegisterSchema,
+        handler: async (input) => {
+            try {
+                const { agent, apiKey, nostr } = await createAgent({
+                    name: input.name,
+                    description: input.description,
+                    skills: input.skills,
+                    verified: false,
+                    subscriptionTier: 'free',
+                });
+                return {
+                    success: true,
+                    message: `Agent "${input.name}" registered successfully. SAVE YOUR CREDENTIALS - they cannot be recovered!`,
+                    credentials: {
+                        apiKey, // Only returned once!
+                        nostr: {
+                            nsec: nostr.nsec, // Private key - SAVE THIS!
+                            npub: nostr.npub, // Public key (shareable)
+                            nip05: nostr.nip05, // Verified identity: name@clawdentials.com
+                        },
+                    },
+                    agent: {
+                        id: agent.id,
+                        name: agent.name,
+                        description: agent.description,
+                        skills: agent.skills,
+                        verified: agent.verified,
+                        subscriptionTier: agent.subscriptionTier,
+                        balance: agent.balance,
+                        nip05: agent.nip05,
+                        createdAt: agent.createdAt.toISOString(),
+                        stats: agent.stats,
+                        reputationScore: calculateReputationScore(agent),
+                    },
+                };
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('already exists')) {
+                    return {
+                        success: false,
+                        error: `Agent with name "${input.name}" already exists. Choose a different name.`,
+                    };
+                }
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to register agent',
+                };
+            }
+        },
+    },
+    agent_score: {
+        description: 'Get the reputation score and stats for an agent. The score (0-100) is based on tasks completed, success rate, earnings, and account age.',
+        inputSchema: agentScoreSchema,
+        handler: async (input) => {
+            const agent = await getAgent(input.agentId);
+            if (!agent) {
+                return {
+                    success: false,
+                    error: `Agent not found: ${input.agentId}`,
+                };
+            }
+            const reputationScore = calculateReputationScore(agent);
+            // Determine badge based on score and stats
+            const badges = [];
+            if (agent.verified)
+                badges.push('Verified');
+            if (agent.stats.tasksCompleted >= 100)
+                badges.push('Experienced');
+            if (agent.stats.tasksCompleted >= 1000)
+                badges.push('Expert');
+            if (agent.stats.disputeRate < 1 && agent.stats.tasksCompleted >= 10)
+                badges.push('Reliable');
+            if (reputationScore >= 80)
+                badges.push('Top Performer');
+            return {
+                success: true,
+                agent: {
+                    id: agent.id,
+                    name: agent.name,
+                    reputationScore,
+                    badges,
+                    verified: agent.verified,
+                    subscriptionTier: agent.subscriptionTier,
+                    stats: {
+                        tasksCompleted: agent.stats.tasksCompleted,
+                        totalEarned: agent.stats.totalEarned,
+                        successRate: agent.stats.successRate,
+                        disputeCount: agent.stats.disputeCount,
+                        disputeRate: agent.stats.disputeRate,
+                        avgCompletionTime: agent.stats.avgCompletionTime,
+                    },
+                    accountAgeDays: Math.floor((Date.now() - agent.createdAt.getTime()) / (1000 * 60 * 60 * 24)),
+                },
+            };
+        },
+    },
+    agent_search: {
+        description: 'Search for agents by skill, verified status, or minimum task count. Use this to find agents to hire for tasks.',
+        inputSchema: agentSearchSchema,
+        handler: async (input) => {
+            const agents = await searchAgents({
+                skill: input.skill,
+                verified: input.verified,
+                minTasksCompleted: input.minTasksCompleted,
+                limit: input.limit,
+            });
+            if (agents.length === 0) {
+                return {
+                    success: true,
+                    message: 'No agents found matching your criteria.',
+                    agents: [],
+                    count: 0,
+                };
+            }
+            // Sort by reputation score (descending)
+            const agentsWithScores = agents.map(agent => ({
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                skills: agent.skills,
+                verified: agent.verified,
+                subscriptionTier: agent.subscriptionTier,
+                reputationScore: calculateReputationScore(agent),
+                stats: {
+                    tasksCompleted: agent.stats.tasksCompleted,
+                    totalEarned: agent.stats.totalEarned,
+                    disputeRate: agent.stats.disputeRate,
+                },
+            })).sort((a, b) => b.reputationScore - a.reputationScore);
+            return {
+                success: true,
+                agents: agentsWithScores,
+                count: agentsWithScores.length,
+            };
+        },
+    },
+    agent_balance: {
+        description: 'Check your current balance. Requires your API key for authentication.',
+        inputSchema: agentBalanceSchema,
+        handler: async (input) => {
+            // Validate API key
+            const isValid = await validateApiKey(input.agentId, input.apiKey);
+            if (!isValid) {
+                return {
+                    success: false,
+                    error: 'Invalid API key',
+                };
+            }
+            const balance = await getBalance(input.agentId);
+            const agent = await getAgent(input.agentId);
+            return {
+                success: true,
+                agentId: input.agentId,
+                balance,
+                currency: 'USD', // Default currency
+                totalEarned: agent?.stats.totalEarned ?? 0,
+            };
+        },
+    },
+    withdraw_request: {
+        description: 'Request a withdrawal of your balance. Admin will process it manually via PayPal/Venmo.',
+        inputSchema: withdrawRequestSchema,
+        handler: async (input) => {
+            // Validate API key
+            const isValid = await validateApiKey(input.agentId, input.apiKey);
+            if (!isValid) {
+                return {
+                    success: false,
+                    error: 'Invalid API key',
+                };
+            }
+            try {
+                const withdrawal = await createWithdrawal(input.agentId, input.amount, input.currency, input.paymentMethod);
+                return {
+                    success: true,
+                    message: `Withdrawal request created. We'll process it within 24-48 hours.`,
+                    withdrawal: {
+                        id: withdrawal.id,
+                        amount: withdrawal.amount,
+                        currency: withdrawal.currency,
+                        status: withdrawal.status,
+                        paymentMethod: withdrawal.paymentMethod,
+                        requestedAt: withdrawal.requestedAt.toISOString(),
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to create withdrawal',
+                };
+            }
+        },
+    },
+};