@kkauto/kkauto-mcp 0.3.3

package/dist/tools/media-form-data.js

@@ -0,0 +1,40 @@
+import { readFile, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
+const maxUploadBytes = 10 * 1024 * 1024;
+export async function buildPostFormData(payload, mediaFiles) {
+    if (Array.isArray(payload.media) && payload.media.length > 0) {
+        throw new Error('Use either media URL array or media_files, not both in the same MCP call.');
+    }
+    if (mediaFiles.length > 15) {
+        throw new Error('media_files accepts at most 15 files.');
+    }
+    const formData = new FormData();
+    const payloadWithoutMediaUrls = { ...payload, media: [] };
+    formData.set('data', JSON.stringify(payloadWithoutMediaUrls));
+    for (const filePath of mediaFiles) {
+        const fileStats = await stat(filePath);
+        if (!fileStats.isFile()) {
+            throw new Error(`media_files entry is not a file: ${filePath}`);
+        }
+        if (fileStats.size > maxUploadBytes) {
+            throw new Error(`media_files entry exceeds 10 MB: ${filePath}`);
+        }
+        const buffer = await readFile(filePath);
+        const blob = new Blob([buffer], { type: mimeTypeForPath(filePath) });
+        formData.append('media[]', blob, basename(filePath));
+    }
+    return formData;
+}
+function mimeTypeForPath(filePath) {
+    const lowerPath = filePath.toLowerCase();
+    if (lowerPath.endsWith('.jpg') || lowerPath.endsWith('.jpeg')) {
+        return 'image/jpeg';
+    }
+    if (lowerPath.endsWith('.png')) {
+        return 'image/png';
+    }
+    if (lowerPath.endsWith('.gif')) {
+        return 'image/gif';
+    }
+    throw new Error('media_files only supports .jpg, .jpeg, .png, or .gif files.');
+}

package/dist/tools/source-crawlers.js

@@ -0,0 +1,326 @@
+import { z } from 'zod';
+const positiveInt = z.number().int().positive();
+const nonEmptyString = z.string().min(1);
+const platformType = z.enum(['facebook', 'tiktok', 'youtube', 'pinterest', 'x', 'instagram', 'douyin', 'other']);
+const sourceType = z.enum(['group', 'page', 'user', 'post', 'hashtag', 'trending', 'other']);
+const crawlerStatus = z.enum(['active', 'inactive', 'paused', 'crawled', 'crawling']);
+const fetchMode = z.enum(['once', 'recurring']);
+const orderDirection = z.enum(['ASC', 'DESC']);
+const crawlerOrderBy = z.enum([
+    'id',
+    'source_name',
+    'source_url',
+    'author_name',
+    'author_url',
+    'platform_type',
+    'source_type',
+    'crawl_interval',
+    'status',
+    'fetch_mode',
+    'last_crawled_at',
+    'next_crawled_at',
+    'total_crawled',
+    'created_at',
+    'updated_at',
+]);
+const relationStatus = z.enum(['active', 'inactive']);
+const accountPermission = z.enum(['viewer', 'editor', 'admin']);
+const jsonRecord = z.record(z.string(), z.unknown());
+const listSchema = {
+    page: positiveInt.optional().describe('Page number, starting at 1.'),
+    limit: positiveInt.optional().describe('Items per page. Capped by KK_MCP_MAX_LIST_LIMIT.'),
+    platform_type: platformType.optional(),
+    status: crawlerStatus.optional(),
+    source_type: sourceType.optional(),
+    fetch_mode: fetchMode.optional(),
+    search: nonEmptyString.optional(),
+    order_by: crawlerOrderBy.optional(),
+    order_direction: orderDirection.optional(),
+};
+const getSchema = {
+    id: positiveInt,
+};
+const postsSchema = {
+    id: positiveInt,
+    page: positiveInt.optional(),
+    limit: positiveInt.optional().describe('Items per page. Capped by KK_MCP_MAX_LIST_LIMIT.'),
+};
+const searchSchema = {
+    q: z.string().optional(),
+};
+const createSchema = {
+    platform_type: platformType,
+    source_type: sourceType,
+    crawl_interval: z.number().int().min(0),
+    source_name: z.string().min(3).max(255).optional(),
+    source_url: z.string().url().max(1000).optional(),
+    author_name: z.string().max(255).optional(),
+    author_url: z.string().url().max(1000).optional(),
+    status: crawlerStatus.optional(),
+    fetch_mode: fetchMode.optional(),
+    source_description: z.string().optional(),
+    source_settings: jsonRecord.optional(),
+    crawl_filters: z.union([jsonRecord, z.string()]).optional(),
+    crawl_keywords: z.union([z.array(z.string().min(1)), z.string()]).optional(),
+};
+const updateSchema = {
+    id: positiveInt,
+    source_name: z.string().min(3).max(255).optional(),
+    source_url: z.string().url().max(1000).optional(),
+    author_name: z.string().max(255).optional(),
+    author_url: z.string().url().max(1000).optional(),
+    platform_type: platformType.optional(),
+    source_type: sourceType.optional(),
+    crawl_interval: z.number().int().min(0).optional(),
+    status: crawlerStatus.optional(),
+    fetch_mode: fetchMode.optional(),
+    source_description: z.string().optional(),
+    source_settings: jsonRecord.optional(),
+    crawl_filters: z.union([jsonRecord, z.string()]).optional(),
+    crawl_keywords: z.union([z.array(z.string().min(1)), z.string()]).optional(),
+};
+const hashtagSchema = {
+    id: positiveInt,
+    hashtag_id: positiveInt,
+    priority: z.number().int().min(1).max(10).optional(),
+    status: relationStatus.optional(),
+};
+const hashtagPrioritySchema = {
+    id: positiveInt,
+    hashtag_id: positiveInt,
+    priority: z.number().int().min(1).max(10),
+};
+const accountSchema = {
+    id: positiveInt,
+    account_id: positiveInt,
+    permission: accountPermission.optional(),
+    status: relationStatus.optional(),
+};
+const bulkAccountSchema = {
+    id: positiveInt,
+    account_ids: z.array(positiveInt).min(1).max(100),
+    permission: accountPermission.optional(),
+    status: relationStatus.optional(),
+    confirm: z.boolean().describe('Must be true because this can link many accounts.'),
+};
+const removeHashtagSchema = {
+    id: positiveInt,
+    hashtag_id: positiveInt,
+    confirm: z.boolean().describe('Must be true to remove a crawler hashtag relation.'),
+    reason: nonEmptyString,
+};
+const removeAccountSchema = {
+    id: positiveInt,
+    account_id: positiveInt,
+    confirm: z.boolean().describe('Must be true to remove a crawler account relation.'),
+    reason: nonEmptyString,
+};
+const deleteSchema = {
+    id: positiveInt,
+    confirm: z.boolean().describe('Must be true for deletion.'),
+    reason: nonEmptyString.describe('Human-readable reason for audit context.'),
+    expected_name: nonEmptyString.optional().describe('Optional source_name guard checked before delete.'),
+};
+export function registerSourceCrawlerTools(server, client, config) {
+    server.registerTool('list_source_crawlers', {
+        title: 'List source crawlers',
+        description: 'List kkAuto API v2 source crawlers with filters and page pagination.',
+        inputSchema: listSchema,
+    }, async (input) => {
+        const response = await client.get('/api/v2/source-crawlers', {
+            query: { ...input, limit: limitOrDefault(input.limit, config) },
+        });
+        return jsonResult(response ?? { status: 'success', data: [], pagination: null });
+    });
+    server.registerTool('get_source_crawler', {
+        title: 'Get source crawler',
+        description: 'Get one source crawler by id, including info, hashtag, and account relations.',
+        inputSchema: getSchema,
+    }, async (input) => jsonResult(await client.get(`/api/v2/source-crawlers/${input.id}`)));
+    server.registerTool('list_source_crawler_posts', {
+        title: 'List source crawler posts',
+        description: 'List source posts attached to one source crawler through kkAuto API v2.',
+        inputSchema: postsSchema,
+    }, async (input) => {
+        const response = await client.get(`/api/v2/source-crawlers/${input.id}/posts`, {
+            query: { page: input.page, limit: limitOrDefault(input.limit, config) },
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('search_source_crawler_hashtags', {
+        title: 'Search source crawler hashtags',
+        description: 'Search hashtag options for source crawler relations.',
+        inputSchema: searchSchema,
+    }, async (input) => jsonResult(await client.get('/api/v2/source-crawlers/search/hashtags', { query: input })));
+    server.registerTool('search_source_crawler_accounts', {
+        title: 'Search source crawler accounts',
+        description: 'Search active FB account options for source crawler relations.',
+        inputSchema: searchSchema,
+    }, async (input) => jsonResult(await client.get('/api/v2/source-crawlers/search/accounts', { query: input })));
+    server.registerTool('create_source_crawler', {
+        title: 'Create source crawler',
+        description: 'Create a source crawler through kkAuto API v2.',
+        inputSchema: createSchema,
+    }, async (input) => {
+        const response = await client.post('/api/v2/source-crawlers', {
+            body: pruneUndefined({ ...input, status: input.status ?? 'paused', fetch_mode: input.fetch_mode ?? 'once' }),
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('update_source_crawler', {
+        title: 'Update source crawler',
+        description: 'Update one source crawler through kkAuto API v2. Fields not supplied are omitted.',
+        inputSchema: updateSchema,
+    }, async (input) => {
+        const { id, ...fields } = input;
+        const payload = pruneUndefined(fields);
+        if (Object.keys(payload).length === 0) {
+            throw new Error('At least one field is required for update_source_crawler');
+        }
+        return jsonResult(await client.put(`/api/v2/source-crawlers/${id}`, { body: payload }));
+    });
+    server.registerTool('pause_source_crawler', {
+        title: 'Pause source crawler',
+        description: 'Pause one source crawler through kkAuto API v2.',
+        inputSchema: getSchema,
+    }, async (input) => jsonResult(await client.patch(`/api/v2/source-crawlers/${input.id}/pause`)));
+    server.registerTool('resume_source_crawler', {
+        title: 'Resume source crawler',
+        description: 'Resume one source crawler through kkAuto API v2. Backend requires linked accounts.',
+        inputSchema: getSchema,
+    }, async (input) => jsonResult(await client.patch(`/api/v2/source-crawlers/${input.id}/resume`)));
+    server.registerTool('list_source_crawler_hashtags', {
+        title: 'List source crawler hashtags',
+        description: 'List hashtag relations for one source crawler.',
+        inputSchema: getSchema,
+    }, async (input) => jsonResult(await client.get(`/api/v2/source-crawlers/${input.id}/hashtags`)));
+    server.registerTool('add_source_crawler_hashtag', {
+        title: 'Add source crawler hashtag',
+        description: 'Add a hashtag relation to one source crawler.',
+        inputSchema: hashtagSchema,
+    }, async (input) => {
+        const { id, ...body } = input;
+        return jsonResult(await client.post(`/api/v2/source-crawlers/${id}/hashtags`, { body: pruneUndefined(body) }));
+    });
+    server.registerTool('update_source_crawler_hashtag_priority', {
+        title: 'Update source crawler hashtag priority',
+        description: 'Update a source crawler hashtag relation priority, from 1 to 10.',
+        inputSchema: hashtagPrioritySchema,
+    }, async (input) => {
+        const response = await client.patch(`/api/v2/source-crawlers/${input.id}/hashtags/${input.hashtag_id}/priority`, {
+            body: { priority: input.priority },
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('remove_source_crawler_hashtag', {
+        title: 'Remove source crawler hashtag',
+        description: 'Remove a hashtag relation from one source crawler. Disabled unless KK_MCP_ENABLE_DELETE=true.',
+        inputSchema: removeHashtagSchema,
+    }, async (input) => {
+        requireDeleteEnabled(config, 'remove_source_crawler_hashtag');
+        requireConfirm(input.confirm, 'remove_source_crawler_hashtag');
+        const preflight = await client.get(`/api/v2/source-crawlers/${input.id}`);
+        const response = await client.delete(`/api/v2/source-crawlers/${input.id}/hashtags/${input.hashtag_id}`);
+        return jsonResult({
+            status: 'success',
+            source_crawler_id: input.id,
+            source_name: extractSourceName(preflight),
+            hashtag_id: input.hashtag_id,
+            reason: input.reason,
+            api_response: response,
+        });
+    });
+    server.registerTool('list_source_crawler_accounts', {
+        title: 'List source crawler accounts',
+        description: 'List account relations for one source crawler.',
+        inputSchema: getSchema,
+    }, async (input) => jsonResult(await client.get(`/api/v2/source-crawlers/${input.id}/accounts`)));
+    server.registerTool('add_source_crawler_account', {
+        title: 'Add source crawler account',
+        description: 'Add one account relation to a source crawler.',
+        inputSchema: accountSchema,
+    }, async (input) => {
+        const { id, ...body } = input;
+        return jsonResult(await client.post(`/api/v2/source-crawlers/${id}/accounts`, { body: pruneUndefined(body) }));
+    });
+    server.registerTool('add_source_crawler_accounts_bulk', {
+        title: 'Add source crawler accounts bulk',
+        description: 'Add up to 100 account relations to one source crawler. Requires confirm=true.',
+        inputSchema: bulkAccountSchema,
+    }, async (input) => {
+        if (!input.confirm) {
+            throw new Error('add_source_crawler_accounts_bulk requires confirm=true');
+        }
+        const { id, confirm: _confirm, ...body } = input;
+        return jsonResult(await client.post(`/api/v2/source-crawlers/${id}/accounts/bulk`, { body: pruneUndefined(body) }));
+    });
+    server.registerTool('remove_source_crawler_account', {
+        title: 'Remove source crawler account',
+        description: 'Remove an account relation from one source crawler. Disabled unless KK_MCP_ENABLE_DELETE=true.',
+        inputSchema: removeAccountSchema,
+    }, async (input) => {
+        requireDeleteEnabled(config, 'remove_source_crawler_account');
+        requireConfirm(input.confirm, 'remove_source_crawler_account');
+        const preflight = await client.get(`/api/v2/source-crawlers/${input.id}`);
+        const response = await client.delete(`/api/v2/source-crawlers/${input.id}/accounts/${input.account_id}`);
+        return jsonResult({
+            status: 'success',
+            source_crawler_id: input.id,
+            source_name: extractSourceName(preflight),
+            account_id: input.account_id,
+            reason: input.reason,
+            api_response: response,
+        });
+    });
+    server.registerTool('delete_source_crawler', {
+        title: 'Delete source crawler',
+        description: 'Delete a source crawler and its relations through kkAuto API v2. Disabled unless KK_MCP_ENABLE_DELETE=true.',
+        inputSchema: deleteSchema,
+    }, async (input) => {
+        requireDeleteEnabled(config, 'delete_source_crawler');
+        requireConfirm(input.confirm, 'delete_source_crawler');
+        const preflight = await client.get(`/api/v2/source-crawlers/${input.id}`);
+        const sourceName = extractSourceName(preflight);
+        if (input.expected_name !== undefined && input.expected_name !== sourceName) {
+            throw new Error('expected_name did not match the current source crawler name; delete aborted');
+        }
+        const response = await client.delete(`/api/v2/source-crawlers/${input.id}`);
+        return jsonResult({
+            status: 'success',
+            deleted_id: input.id,
+            deleted_name: sourceName,
+            reason: input.reason,
+            api_response: response,
+        });
+    });
+}
+function jsonResult(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+function pruneUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function limitOrDefault(value, config) {
+    return value ? Math.min(value, config.maxListLimit) : config.maxListLimit;
+}
+function requireDeleteEnabled(config, toolName) {
+    if (!config.enableDelete) {
+        throw new Error(`${toolName} is disabled. Set KK_MCP_ENABLE_DELETE=true to enable it.`);
+    }
+}
+function requireConfirm(confirmed, toolName) {
+    if (!confirmed) {
+        throw new Error(`${toolName} requires confirm=true`);
+    }
+}
+function extractSourceName(response) {
+    const crawler = response?.data?.crawler;
+    return crawler && typeof crawler.source_name === 'string' ? crawler.source_name : undefined;
+}

package/dist/tools/source-posts.js

@@ -0,0 +1,281 @@
+import { z } from 'zod';
+const positiveInt = z.number().int().positive();
+const nonEmptyString = z.string().min(1);
+const sourcePlatform = z.enum([
+    'facebook',
+    'instagram',
+    'twitter',
+    'youtube',
+    'tiktok',
+    'reddit',
+    'pinterest',
+    'website',
+    'linkedin',
+    'telegram',
+    'discord',
+    'other',
+]);
+const workflowStatus = z.enum(['pending', 'approved', 'rejected', 'waiting_confirmation']);
+const sourceFormat = z.enum(['feed_post', 'reel', 'story', 'short', 'live', 'carousel', 'article', 'unknown', 'other']);
+const topicType = z.enum(['normal', 'tutorial', 'share', 'review', 'comparison', 'introduction', 'promotion', 'news', 'event']);
+const lengthType = z.enum(['short', 'medium', 'long']);
+const contentShape = z.enum(['text_only', 'image_only', 'video_only', 'text_image', 'text_video', 'image_video', 'text_image_video']);
+const orderDirection = z.enum(['ASC', 'DESC']);
+const orderBy = z.enum(['published_at', 'id', 'created_at', 'updated_at', 'quality_score', 'popularity_score']);
+const mediaPayload = z.object({
+    media_type: z.enum(['image', 'video']).default('image'),
+    media_url: z.string().url(),
+});
+const listSchema = {
+    source_platform: sourcePlatform.optional(),
+    workflow_status: workflowStatus.optional().describe('Canonical lifecycle status. Use status only for API compatibility checks.'),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    source_format: sourceFormat.optional(),
+    topic_type: topicType.optional(),
+    content_shape: contentShape.optional(),
+    length_type: lengthType.optional(),
+    post_type: lengthType.optional().describe('Deprecated API alias for length_type.'),
+    hashtag: nonEmptyString.optional(),
+    date_from: nonEmptyString.optional(),
+    date_to: nonEmptyString.optional(),
+    search: nonEmptyString.optional(),
+    order_by: orderBy.optional(),
+    order_direction: orderDirection.optional(),
+    limit: positiveInt.optional().describe('Result limit. Capped by KK_MCP_MAX_LIST_LIMIT.'),
+    offset: z.number().int().min(0).optional(),
+};
+const getSchema = {
+    id: positiveInt,
+};
+const createSchema = {
+    title: z.string().min(3).max(500),
+    content: nonEmptyString,
+    source_platform: sourcePlatform,
+    source_channel: z.string().min(1).max(255),
+    source_author: z.string().min(1).max(255),
+    source_url: z.string().url().max(1000),
+    source_post_id: z.string().min(1).max(255),
+    published_at: nonEmptyString.describe('Publish timestamp accepted by kkAuto API valid_date, e.g. 2026-05-26 10:30:00.'),
+    source_format: sourceFormat.optional(),
+    workflow_status: workflowStatus.optional(),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    topic_type: topicType.optional(),
+    length_type: lengthType.optional(),
+    post_type: lengthType.optional().describe('Deprecated API alias for length_type.'),
+    source_crawler_id: positiveInt.optional(),
+    media: z.array(mediaPayload).max(50).optional(),
+    hashtags: z.union([z.string(), z.array(z.string().min(1))]).optional(),
+    comments: z.array(z.record(z.string(), z.unknown())).max(200).optional(),
+    analytics: z.record(z.string(), z.unknown()).optional(),
+};
+const updateSchema = {
+    id: positiveInt,
+    title: z.string().min(3).max(500).optional(),
+    content: nonEmptyString.optional(),
+    source_platform: sourcePlatform.optional(),
+    source_channel: z.string().min(1).max(255).optional(),
+    source_author: z.string().min(1).max(255).optional(),
+    source_url: z.string().url().max(1000).optional(),
+    source_format: sourceFormat.optional(),
+    workflow_status: workflowStatus.optional(),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    topic_type: topicType.optional(),
+    length_type: lengthType.optional(),
+    post_type: lengthType.optional().describe('Deprecated API alias for length_type.'),
+    media: z.array(mediaPayload).max(50).optional().describe('Only send when replacing media rows.'),
+};
+const searchSchema = {
+    q: nonEmptyString,
+    workflow_status: workflowStatus.optional(),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    limit: positiveInt.optional().describe('Result limit. Capped by KK_MCP_MAX_LIST_LIMIT.'),
+    offset: z.number().int().min(0).optional(),
+};
+const byPlatformSchema = {
+    platform: sourcePlatform,
+    workflow_status: workflowStatus.optional(),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    limit: positiveInt.optional().describe('Result limit. Capped by KK_MCP_MAX_LIST_LIMIT.'),
+    offset: z.number().int().min(0).optional(),
+};
+const byHashtagSchema = {
+    hashtag: nonEmptyString,
+    workflow_status: workflowStatus.optional(),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    limit: positiveInt.optional().describe('Result limit. Capped by KK_MCP_MAX_LIST_LIMIT.'),
+    offset: z.number().int().min(0).optional(),
+};
+const statusSchema = {
+    id: positiveInt,
+    workflow_status: workflowStatus.optional(),
+    status: workflowStatus.optional().describe('Deprecated API alias for workflow_status.'),
+    notes: z.string().optional(),
+};
+const deleteSchema = {
+    id: positiveInt,
+    confirm: z.boolean().describe('Must be true for deletion.'),
+    reason: nonEmptyString.describe('Human-readable reason for audit context.'),
+    expected_title: nonEmptyString.optional().describe('Optional title guard checked before delete.'),
+};
+export function registerSourcePostTools(server, client, config) {
+    server.registerTool('list_source_posts', {
+        title: 'List source posts',
+        description: 'List kkAuto API v2 source posts with filters and offset pagination.',
+        inputSchema: listSchema,
+    }, async (input) => {
+        const response = await client.get('/api/v2/source-posts', {
+            query: { ...input, limit: limitOrDefault(input.limit, config) },
+        });
+        return jsonResult(response ?? { success: true, data: [], total: 0, filters: {} });
+    });
+    server.registerTool('get_source_post', {
+        title: 'Get source post',
+        description: 'Get one kkAuto API v2 source post by id, including API-provided details.',
+        inputSchema: getSchema,
+    }, async (input) => jsonResult(await client.get(`/api/v2/source-posts/${input.id}`)));
+    server.registerTool('search_source_posts', {
+        title: 'Search source posts',
+        description: 'Search source posts by keyword through kkAuto API v2.',
+        inputSchema: searchSchema,
+    }, async (input) => {
+        const response = await client.get('/api/v2/source-posts/search', {
+            query: { ...input, limit: limitOrDefault(input.limit, config) },
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('list_source_posts_by_platform', {
+        title: 'List source posts by platform',
+        description: 'List source posts for one platform through kkAuto API v2.',
+        inputSchema: byPlatformSchema,
+    }, async (input) => {
+        const { platform, ...query } = input;
+        const response = await client.get(`/api/v2/source-posts/by-platform/${platform}`, {
+            query: { ...query, limit: limitOrDefault(input.limit, config) },
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('list_source_posts_by_hashtag', {
+        title: 'List source posts by hashtag',
+        description: 'List source posts for one hashtag through kkAuto API v2.',
+        inputSchema: byHashtagSchema,
+    }, async (input) => {
+        const { hashtag, ...query } = input;
+        const response = await client.get(`/api/v2/source-posts/by-hashtag/${encodeURIComponent(hashtag)}`, {
+            query: { ...query, limit: limitOrDefault(input.limit, config) },
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('get_source_post_statistics', {
+        title: 'Get source post statistics',
+        description: 'Get kkAuto API v2 aggregate statistics for source posts.',
+        inputSchema: {},
+    }, async () => jsonResult(await client.get('/api/v2/source-posts/statistics')));
+    server.registerTool('create_source_post', {
+        title: 'Create source post',
+        description: 'Create a source post through kkAuto API v2. Uses remote media URLs only.',
+        inputSchema: createSchema,
+    }, async (input) => {
+        const payload = pruneUndefined({
+            ...input,
+            source_format: input.source_format ?? 'unknown',
+            workflow_status: input.workflow_status ?? input.status ?? 'pending',
+            topic_type: input.topic_type ?? 'normal',
+            length_type: input.length_type ?? input.post_type ?? 'short',
+            hashtags: normalizeHashtags(input.hashtags),
+        });
+        const response = await client.post('/api/v2/source-posts', { body: payload });
+        return jsonResult(response);
+    });
+    server.registerTool('update_source_post', {
+        title: 'Update source post',
+        description: 'Update one source post through kkAuto API v2. Fields not supplied are omitted.',
+        inputSchema: updateSchema,
+    }, async (input) => {
+        const { id, ...fields } = input;
+        const payload = pruneUndefined({
+            ...fields,
+            workflow_status: fields.workflow_status ?? fields.status,
+            length_type: fields.length_type ?? fields.post_type,
+        });
+        if (Object.keys(payload).length === 0) {
+            throw new Error('At least one field is required for update_source_post');
+        }
+        const response = await client.put(`/api/v2/source-posts/${id}`, { body: payload });
+        return jsonResult(response);
+    });
+    server.registerTool('update_source_post_status', {
+        title: 'Update source post status',
+        description: 'Update one source post workflow status through kkAuto API v2.',
+        inputSchema: statusSchema,
+    }, async (input) => {
+        const status = input.workflow_status ?? input.status;
+        if (status === undefined) {
+            throw new Error('update_source_post_status requires workflow_status or status');
+        }
+        const response = await client.patch(`/api/v2/source-posts/${input.id}/status`, {
+            body: pruneUndefined({ workflow_status: status, notes: input.notes }),
+        });
+        return jsonResult(response);
+    });
+    server.registerTool('delete_source_post', {
+        title: 'Delete source post',
+        description: 'Delete a source post through kkAuto API v2. Disabled unless KK_MCP_ENABLE_DELETE=true.',
+        inputSchema: deleteSchema,
+    }, async (input) => {
+        if (!config.enableDelete) {
+            throw new Error('delete_source_post is disabled. Set KK_MCP_ENABLE_DELETE=true to enable it.');
+        }
+        if (!input.confirm) {
+            throw new Error('delete_source_post requires confirm=true');
+        }
+        const preflight = await client.get(`/api/v2/source-posts/${input.id}`);
+        const title = extractTitle(preflight);
+        if (input.expected_title !== undefined && input.expected_title !== title) {
+            throw new Error('expected_title did not match the current source post title; delete aborted');
+        }
+        const response = await client.delete(`/api/v2/source-posts/${input.id}`);
+        return jsonResult({
+            status: 'success',
+            deleted_id: input.id,
+            deleted_title: title,
+            reason: input.reason,
+            api_response: response,
+        });
+    });
+}
+function jsonResult(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}
+function pruneUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function limitOrDefault(value, config) {
+    return value ? Math.min(value, config.maxListLimit) : config.maxListLimit;
+}
+function normalizeHashtags(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return [];
+    }
+    return trimmed
+        .split(/[\s,]+/)
+        .map((entry) => entry.trim().replace(/^#+/, ''))
+        .filter((entry) => entry !== '');
+}
+function extractTitle(response) {
+    const data = response?.data;
+    return data && typeof data.title === 'string' ? data.title : undefined;
+}