openclaw-overlay-plugin 0.7.22

package/dist/scripts/wallet/identity.js

@@ -0,0 +1,151 @@
+/**
+ * Wallet identity helpers.
+ */
+import fs from 'node:fs';
+import { PATHS } from '../config.js';
+import { CachedKeyDeriver, Utils } from '@bsv/sdk';
+import { brc29ProtocolID } from '@bsv/wallet-toolbox';
+// Dynamic import for @bsv/sdk
+let _sdk = null;
+async function getSdk() {
+    if (_sdk)
+        return _sdk;
+    try {
+        _sdk = await import('@bsv/sdk');
+        return _sdk;
+    }
+    catch {
+        const { fileURLToPath } = await import('node:url');
+        const path = await import('node:path');
+        const os = await import('node:os');
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(__dirname, '..', '..', '..', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(__dirname, '..', '..', '..', '..', '..', 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(os.homedir(), 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+        ];
+        for (const p of candidates) {
+            try {
+                _sdk = await import(p);
+                return _sdk;
+            }
+            catch {
+                // Try next
+            }
+        }
+        throw new Error('Cannot find @bsv/sdk. Run setup.sh first.');
+    }
+}
+/**
+ * Load wallet identity from disk.
+ * @returns Identity object with rootKeyHex and identityKey
+ * @throws Error if wallet not initialized
+ */
+export function loadWalletIdentity() {
+    if (!fs.existsSync(PATHS.walletIdentity)) {
+        throw new Error('Wallet not initialized. Run: cli setup');
+    }
+    // Security warning for overly permissive file mode
+    try {
+        const fileMode = fs.statSync(PATHS.walletIdentity).mode & 0o777;
+        if (fileMode & 0o044) { // world or group readable
+            console.error(`[security] WARNING: ${PATHS.walletIdentity} has permissive mode 0${fileMode.toString(8)}. Run: chmod 600 ${PATHS.walletIdentity}`);
+        }
+    }
+    catch {
+        // Ignore stat errors
+    }
+    return JSON.parse(fs.readFileSync(PATHS.walletIdentity, 'utf-8'));
+}
+/**
+ * Load identity and private key for relay message signing.
+ * @returns Object with identityKey and privKey
+ */
+export async function loadIdentity() {
+    const identity = loadWalletIdentity();
+    const sdk = await getSdk();
+    const privKey = sdk.PrivateKey.fromHex(identity.rootKeyHex);
+    return { identityKey: identity.identityKey, privKey };
+}
+/**
+ * Sign a relay message using ECDSA.
+ * @param privKey - Private key for signing
+ * @param to - Recipient's identity key
+ * @param type - Message type
+ * @param payload - Message payload
+ * @returns Hex-encoded DER signature
+ */
+export async function signRelayMessage(privKey, to, type, payload) {
+    const sdk = await getSdk();
+    const preimage = to + type + JSON.stringify(payload);
+    const msgHash = sdk.Hash.sha256(Array.from(new TextEncoder().encode(preimage)));
+    const sig = privKey.sign(msgHash);
+    return Array.from(sig.toDER()).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Verify a relay message signature.
+ * @param fromKey - Sender's public key
+ * @param to - Recipient's identity key
+ * @param type - Message type
+ * @param payload - Message payload
+ * @param signatureHex - Hex-encoded DER signature
+ * @returns Verification result
+ */
+export async function verifyRelaySignature(fromKey, to, type, payload, signatureHex) {
+    if (!signatureHex)
+        return { valid: false, reason: 'no signature' };
+    try {
+        const sdk = await getSdk();
+        const preimage = to + type + JSON.stringify(payload);
+        const msgHash = sdk.Hash.sha256(Array.from(new TextEncoder().encode(preimage)));
+        const sigBytes = [];
+        for (let i = 0; i < signatureHex.length; i += 2) {
+            sigBytes.push(parseInt(signatureHex.substring(i, i + 2), 16));
+        }
+        const sig = sdk.Signature.fromDER(sigBytes);
+        const pubKey = sdk.PublicKey.fromString(fromKey);
+        return { valid: pubKey.verify(msgHash, sig) };
+    }
+    catch (err) {
+        return { valid: false, reason: String(err) };
+    }
+}
+/**
+ * Derive wallet address components from a private key.
+ *
+ * IMPORTANT: This uses BRC-29 key derivation to create a child key.
+ * Any transactions spending to this address MUST use the matching
+ * child private key for signing, NOT the root key.
+ *
+ * Use deriveWalletKeys() to get both the address and signing key.
+ */
+export async function deriveWalletAddress(privKey) {
+    const keyDeriver = new CachedKeyDeriver(privKey);
+    const pubKey = keyDeriver.derivePublicKey(brc29ProtocolID, Utils.toBase64(Utils.toArray('import')) + ' ' + Utils.toBase64(Utils.toArray('now')), 'self', true);
+    const address = pubKey.toAddress();
+    const hash160 = Buffer.from(pubKey.toHash());
+    return { address, hash160, pubKey };
+}
+/**
+ * Derive wallet keys for both address AND transaction signing.
+ *
+ * CRITICAL: Use this function to get the child private key for signing
+ * transactions that spend from the derived address. Do NOT use the
+ * root private key - it will cause signature verification failures!
+ *
+ * @param rootPrivKey - Root private key from wallet identity
+ * @returns Object with address, hash160, and CHILD private key for signing
+ */
+export async function deriveWalletKeys(rootPrivKey) {
+    const keyDeriver = new CachedKeyDeriver(rootPrivKey);
+    const derivationPrefix = Utils.toBase64(Utils.toArray('import'));
+    const derivationSuffix = Utils.toBase64(Utils.toArray('now'));
+    const keyString = `${derivationPrefix} ${derivationSuffix}`;
+    // Derive child private key (for signing)
+    const childPrivKey = keyDeriver.derivePrivateKey(brc29ProtocolID, keyString, 'self');
+    // Derive child public key (for address)
+    const pubKey = keyDeriver.derivePublicKey(brc29ProtocolID, keyString, 'self', true);
+    const address = pubKey.toAddress();
+    const hash160 = Buffer.from(pubKey.toHash());
+    return { address, hash160, pubKey, childPrivKey };
+}

package/dist/scripts/wallet/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Wallet module exports.
+ */
+export * from './identity.js';
+export * from './setup.js';
+export * from './balance.js';

package/dist/scripts/wallet/index.js

@@ -0,0 +1,6 @@
+/**
+ * Wallet module exports.
+ */
+export * from './identity.js';
+export * from './setup.js';
+export * from './balance.js';

package/dist/scripts/wallet/setup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wallet setup commands: setup, identity, address.
+ */
+/**
+ * Setup command: create wallet and show identity.
+ */
+export declare function cmdSetup(): Promise<never>;
+/**
+ * Identity command: show identity public key.
+ */
+export declare function cmdIdentity(): Promise<never>;
+/**
+ * Address command: show P2PKH receive address.
+ */
+export declare function cmdAddress(): Promise<never>;

package/dist/scripts/wallet/setup.js

@@ -0,0 +1,105 @@
+/**
+ * Wallet setup commands: setup, identity, address.
+ */
+import fs from 'node:fs';
+import { NETWORK, WALLET_DIR, OVERLAY_URL, PATHS } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadWalletIdentity, deriveWalletAddress } from './identity.js';
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+// Dynamic import for @bsv/sdk
+let _sdk = null;
+async function getSdk() {
+    if (_sdk)
+        return _sdk;
+    try {
+        _sdk = await import('@bsv/sdk');
+        return _sdk;
+    }
+    catch {
+        const { fileURLToPath } = await import('node:url');
+        const path = await import('node:path');
+        const os = await import('node:os');
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(__dirname, '..', '..', '..', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(__dirname, '..', '..', '..', '..', '..', 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(os.homedir(), 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+        ];
+        for (const p of candidates) {
+            try {
+                _sdk = await import(p);
+                return _sdk;
+            }
+            catch {
+                // Try next
+            }
+        }
+        throw new Error('Cannot find @bsv/sdk. Run setup.sh first.');
+    }
+}
+/**
+ * Setup command: create wallet and show identity.
+ */
+export async function cmdSetup() {
+    const BSVAgentWallet = await getBSVAgentWallet();
+    if (fs.existsSync(PATHS.walletIdentity)) {
+        const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+        const identityKey = await wallet.getIdentityKey();
+        await wallet.destroy();
+        return ok({
+            identityKey,
+            walletDir: WALLET_DIR,
+            network: NETWORK,
+            overlayUrl: OVERLAY_URL,
+            alreadyExisted: true,
+        });
+    }
+    fs.mkdirSync(WALLET_DIR, { recursive: true });
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey = await wallet.getIdentityKey();
+    await wallet.destroy();
+    // Restrict permissions on wallet-identity.json (contains private key)
+    if (fs.existsSync(PATHS.walletIdentity)) {
+        fs.chmodSync(PATHS.walletIdentity, 0o600);
+    }
+    return ok({
+        identityKey,
+        walletDir: WALLET_DIR,
+        network: NETWORK,
+        overlayUrl: OVERLAY_URL,
+        alreadyExisted: false,
+    });
+}
+/**
+ * Identity command: show identity public key.
+ */
+export async function cmdIdentity() {
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey = await wallet.getIdentityKey();
+    await wallet.destroy();
+    return ok({ identityKey });
+}
+/**
+ * Address command: show P2PKH receive address.
+ */
+export async function cmdAddress() {
+    if (!fs.existsSync(PATHS.walletIdentity)) {
+        return fail('Wallet not initialized. Run: setup');
+    }
+    const sdk = await getSdk();
+    const identity = loadWalletIdentity();
+    const privKey = sdk.PrivateKey.fromHex(identity.rootKeyHex);
+    const { address } = await deriveWalletAddress(privKey);
+    return ok({
+        address,
+        network: NETWORK,
+        identityKey: identity.identityKey,
+        note: NETWORK === 'mainnet'
+            ? `Fund this address at an exchange — Explorer: https://whatsonchain.com/address/${address}`
+            : `Fund via faucet: https://witnessonchain.com/faucet/tbsv — Explorer: https://test.whatsonchain.com/address/${address}`,
+    });
+}

package/dist/scripts/x-verification/commands.d.ts

@@ -0,0 +1,27 @@
+/**
+ * X (Twitter) verification commands.
+ */
+/**
+ * Start X verification: generate a tweet with identity key and signature.
+ */
+export declare function cmdXVerifyStart(handleArg: string | undefined): Promise<never>;
+/**
+ * Complete X verification by checking the posted tweet.
+ */
+export declare function cmdXVerifyComplete(tweetUrl: string | undefined): Promise<never>;
+/**
+ * List verified X accounts (local cache).
+ */
+export declare function cmdXVerifications(): Promise<never>;
+/**
+ * Lookup X verifications from the overlay network.
+ */
+export declare function cmdXLookup(query: string | undefined): Promise<never>;
+/**
+ * List pending X engagement requests.
+ */
+export declare function cmdXEngagementQueue(): Promise<never>;
+/**
+ * Mark an X engagement request as fulfilled.
+ */
+export declare function cmdXEngagementFulfill(requestId: string | undefined, proofUrl?: string): Promise<never>;

package/dist/scripts/x-verification/commands.js

@@ -0,0 +1,222 @@
+/**
+ * X (Twitter) verification commands.
+ */
+import fs from 'node:fs';
+import { PROTOCOL_ID, TOPICS, LOOKUP_SERVICES, PATHS } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadIdentity } from '../wallet/identity.js';
+import { loadXVerifications, saveXVerifications, readJsonl, ensureStateDir } from '../utils/storage.js';
+import { buildRealOverlayTransaction, lookupOverlay } from '../overlay/transaction.js';
+// Dynamic import for @bsv/sdk
+let _sdk = null;
+async function getSdk() {
+    if (_sdk)
+        return _sdk;
+    try {
+        _sdk = await import('@bsv/sdk');
+        return _sdk;
+    }
+    catch {
+        const { fileURLToPath } = await import('node:url');
+        const path = await import('node:path');
+        const os = await import('node:os');
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(__dirname, '..', '..', '..', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(__dirname, '..', '..', '..', '..', '..', 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(os.homedir(), 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+        ];
+        for (const p of candidates) {
+            try {
+                _sdk = await import(p);
+                return _sdk;
+            }
+            catch {
+                // Try next
+            }
+        }
+        throw new Error('Cannot find @bsv/sdk. Run setup.sh first.');
+    }
+}
+/**
+ * Start X verification: generate a tweet with identity key and signature.
+ */
+export async function cmdXVerifyStart(handleArg) {
+    if (!handleArg) {
+        return fail('Usage: x-verify-start <@handle>');
+    }
+    const sdk = await getSdk();
+    const handle = handleArg.startsWith('@') ? handleArg : `@${handleArg}`;
+    const { identityKey, privKey } = await loadIdentity();
+    // Sign the verification message
+    const message = `Verify ${identityKey}`;
+    const msgHash = sdk.Hash.sha256(Array.from(new TextEncoder().encode(message)));
+    const sig = privKey.sign(msgHash);
+    const signatureHex = Array.from(sig.toDER()).map((b) => b.toString(16).padStart(2, '0')).join('');
+    // Save pending verification
+    const pending = {
+        identityKey,
+        handle,
+        signature: signatureHex,
+        message,
+        createdAt: new Date().toISOString(),
+    };
+    ensureStateDir();
+    fs.writeFileSync(PATHS.pendingXVerification, JSON.stringify(pending, null, 2));
+    // Build tweet text (under 280 chars)
+    // Use shortened signature (first 40 chars) to fit in tweet
+    const tweetText = `BSV Agent Verify: ${identityKey.slice(0, 10)}...${identityKey.slice(-10)} sig:${signatureHex.slice(0, 40)}`;
+    return ok({
+        tweetText,
+        handle,
+        identityKey,
+        signature: signatureHex,
+        note: `Post the tweet above from ${handle}, then run: x-verify-complete <tweet_url>`,
+    });
+}
+/**
+ * Complete X verification by checking the posted tweet.
+ */
+export async function cmdXVerifyComplete(tweetUrl) {
+    if (!tweetUrl)
+        return fail('Usage: x-verify-complete <tweet-url>');
+    // Load pending verification
+    if (!fs.existsSync(PATHS.pendingXVerification)) {
+        return fail('No pending X verification. Run x-verify-start first.');
+    }
+    const pending = JSON.parse(fs.readFileSync(PATHS.pendingXVerification, 'utf-8'));
+    // Extract tweet ID from URL
+    const tweetIdMatch = tweetUrl.match(/status\/(\d+)/);
+    if (!tweetIdMatch)
+        return fail('Invalid tweet URL. Expected format: https://x.com/user/status/123456789');
+    const tweetId = tweetIdMatch[1];
+    // Fetch the tweet using bird CLI
+    let tweetData;
+    try {
+        const { execSync } = await import('child_process');
+        const birdOutput = execSync(`bird read ${tweetUrl} --json 2>/dev/null`, {
+            encoding: 'utf-8',
+            timeout: 30000,
+        });
+        tweetData = JSON.parse(birdOutput);
+    }
+    catch (err) {
+        return fail(`Failed to fetch tweet: ${err.message}. Make sure bird CLI is configured.`);
+    }
+    // Verify the tweet contains our identity key and partial signature
+    const tweetText = tweetData.text || tweetData.full_text || '';
+    if (!tweetText.includes(pending.identityKey.slice(0, 10))) {
+        return fail('Tweet does not contain the expected identity key.');
+    }
+    // Check for partial signature (first 40 chars)
+    if (!tweetText.includes(pending.signature.slice(0, 40))) {
+        return fail('Tweet does not contain the expected verification signature prefix.');
+    }
+    // Get the X user info from the tweet
+    const xUserId = tweetData.user?.id_str || tweetData.authorId || tweetData.author?.id || tweetData.user_id;
+    const xHandle = tweetData.user?.screen_name || tweetData.author?.username || tweetData.author?.name || pending.handle.replace('@', '');
+    if (!xUserId) {
+        return fail('Could not extract X user ID from tweet data.');
+    }
+    // Build on-chain verification record
+    const verificationPayload = {
+        protocol: PROTOCOL_ID,
+        type: 'x-verification',
+        identityKey: pending.identityKey,
+        xHandle: `@${xHandle}`,
+        xUserId,
+        tweetId,
+        tweetUrl,
+        signature: pending.signature,
+        verifiedAt: new Date().toISOString(),
+    };
+    // Submit to overlay (may fail if topic manager not deployed yet)
+    let result = { txid: null, funded: 'pending-server-support' };
+    let onChainStored = false;
+    try {
+        result = await buildRealOverlayTransaction(verificationPayload, TOPICS.X_VERIFICATION);
+        onChainStored = true;
+    }
+    catch (err) {
+        console.error(`[x-verify] On-chain storage failed: ${err.message}`);
+        console.error('[x-verify] Storing verification locally.');
+    }
+    // Save verification locally
+    const verifications = loadXVerifications();
+    verifications.push({
+        ...verificationPayload,
+        txid: result.txid,
+    });
+    saveXVerifications(verifications);
+    // Clean up pending
+    fs.unlinkSync(PATHS.pendingXVerification);
+    return ok({
+        verified: true,
+        identityKey: pending.identityKey,
+        xHandle: `@${xHandle}`,
+        xUserId,
+        tweetId,
+        txid: result.txid,
+        funded: result.funded,
+        onChainStored,
+        note: onChainStored ? undefined : 'Stored locally. On-chain anchoring pending server topic manager deployment.',
+    });
+}
+/**
+ * List verified X accounts (local cache).
+ */
+export async function cmdXVerifications() {
+    const verifications = loadXVerifications();
+    return ok({ verifications, count: verifications.length });
+}
+/**
+ * Lookup X verifications from the overlay network.
+ */
+export async function cmdXLookup(query) {
+    try {
+        const lookupQuery = query
+            ? (query.startsWith('@') ? { xHandle: query } : { identityKey: query })
+            : { type: 'list' };
+        const response = await lookupOverlay(LOOKUP_SERVICES.X_VERIFICATIONS, lookupQuery);
+        return ok({ verifications: response.outputs || response || [], query: lookupQuery });
+    }
+    catch {
+        return ok({ verifications: [], query, note: 'X verification lookup service may not be deployed yet.' });
+    }
+}
+/**
+ * List pending X engagement requests.
+ */
+export async function cmdXEngagementQueue() {
+    if (!fs.existsSync(PATHS.xEngagementQueue)) {
+        return ok({ queue: [], count: 0 });
+    }
+    const queue = readJsonl(PATHS.xEngagementQueue).filter(e => e.status === 'pending');
+    return ok({ queue, count: queue.length });
+}
+/**
+ * Mark an X engagement request as fulfilled.
+ */
+export async function cmdXEngagementFulfill(requestId, proofUrl) {
+    if (!requestId)
+        return fail('Usage: x-engagement-fulfill <requestId> [proofUrl]');
+    if (!fs.existsSync(PATHS.xEngagementQueue)) {
+        return fail('No engagement queue found.');
+    }
+    const queue = readJsonl(PATHS.xEngagementQueue);
+    const entryIndex = queue.findIndex(e => e.requestId === requestId);
+    if (entryIndex === -1) {
+        return fail(`Request ${requestId} not found in queue.`);
+    }
+    // Mark as fulfilled
+    queue[entryIndex].status = 'fulfilled';
+    queue[entryIndex].fulfilledAt = new Date().toISOString();
+    queue[entryIndex].proofUrl = proofUrl || null;
+    // Rewrite queue file
+    fs.writeFileSync(PATHS.xEngagementQueue, queue.map(e => JSON.stringify(e)).join('\n') + '\n');
+    return ok({
+        fulfilled: true,
+        requestId,
+        entry: queue[entryIndex],
+    });
+}

package/dist/scripts/x-verification/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * X verification module exports.
+ */
+export * from './commands.js';

package/dist/scripts/x-verification/index.js

@@ -0,0 +1,4 @@
+/**
+ * X verification module exports.
+ */
+export * from './commands.js';

package/dist/services/built-in/api-proxy/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * API Proxy service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const apiProxyService: ServiceDefinition;
+export default apiProxyService;

package/dist/services/built-in/api-proxy/index.js

@@ -0,0 +1,23 @@
+/**
+ * API Proxy service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const apiProxyService = {
+    id: 'api-proxy',
+    name: 'API Proxy',
+    description: 'Proxy HTTP requests to external APIs. Input: {url, method, headers, body}.',
+    defaultPrice: 15,
+    category: ServiceCategory.UTILITY,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'Target API URL' },
+            method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'], description: 'HTTP method' },
+            headers: { type: 'object', description: 'Request headers' },
+            body: { description: 'Request body' },
+            timeout: { type: 'number', description: 'Request timeout in ms' }
+        },
+        required: ['url']
+    }
+};
+export default apiProxyService;

package/dist/services/built-in/code-develop/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Code Development service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const codeDevelopService: ServiceDefinition;
+export default codeDevelopService;

package/dist/services/built-in/code-develop/index.js

@@ -0,0 +1,23 @@
+/**
+ * Code Development service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const codeDevelopService = {
+    id: 'code-develop',
+    name: 'Code Development',
+    description: 'Generate code from requirements. Specify language, task description, and constraints.',
+    defaultPrice: 100,
+    category: ServiceCategory.DEVELOPMENT,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            requirements: { type: 'string', description: 'Detailed description of what code to generate' },
+            language: { type: 'string', description: 'Programming language (e.g., JavaScript, Python, Java)' },
+            constraints: { type: 'string', description: 'Any specific constraints or requirements' },
+            style: { type: 'string', description: 'Code style preferences' },
+            includeTests: { type: 'boolean', description: 'Whether to include unit tests' }
+        },
+        required: ['requirements', 'language']
+    }
+};
+export default codeDevelopService;

package/dist/services/built-in/code-review/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Code Review service definition.
+ *
+ * Provides thorough code review covering bugs, security issues, style,
+ * performance, and improvement suggestions. This is an agent-mode service
+ * that leverages the LLM's capabilities.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const codeReviewService: ServiceDefinition;
+export default codeReviewService;

package/dist/services/built-in/code-review/index.js

@@ -0,0 +1,51 @@
+/**
+ * Code Review service definition.
+ *
+ * Provides thorough code review covering bugs, security issues, style,
+ * performance, and improvement suggestions. This is an agent-mode service
+ * that leverages the LLM's capabilities.
+ */
+import { ServiceCategory } from '../../types.js';
+const codeReviewService = {
+    id: 'code-review',
+    name: 'Code Review',
+    description: 'Thorough code review covering bugs, security issues, style, performance, and improvement suggestions.',
+    defaultPrice: 50,
+    category: ServiceCategory.DEVELOPMENT,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            code: {
+                type: 'string',
+                description: 'Code to review'
+            },
+            language: {
+                type: 'string',
+                description: 'Programming language (auto-detected if not provided)'
+            },
+            prUrl: {
+                type: 'string',
+                description: 'GitHub/GitLab PR URL to review instead of direct code'
+            },
+            focusAreas: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['security', 'performance', 'style', 'bugs', 'maintainability', 'testing']
+                },
+                description: 'Specific areas to focus the review on'
+            },
+            severity: {
+                type: 'string',
+                enum: ['basic', 'detailed', 'comprehensive'],
+                description: 'Depth of review (default: detailed)'
+            }
+        },
+        anyOf: [
+            { required: ['code'] },
+            { required: ['prUrl'] }
+        ]
+    }
+    // No handler - this service uses agent mode for full LLM capabilities
+};
+export default codeReviewService;