@n0ml1/farm-mcp 1.0.0

package/dist/api/client.js

@@ -0,0 +1,32 @@
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/+$/, "");
+        this.apiKey = apiKey;
+    }
+    async request(method, path, body) {
+        const headers = {};
+        if (this.apiKey) {
+            headers["Authorization"] = this.apiKey;
+        }
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        if (response.status === 204) {
+            return undefined;
+        }
+        const text = await response.text();
+        const data = text ? JSON.parse(text) : undefined;
+        if (!response.ok) {
+            const errorMessage = data?.error || data?.message || response.statusText;
+            throw new Error(`${response.status} ${errorMessage}`);
+        }
+        return data;
+    }
+}

package/dist/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ApiClient } from "./api/client.js";
+import { createServer } from "./server.js";
+const parseCliArgs = (argv) => {
+    const options = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--baseUrl" || arg === "-b") {
+            const value = argv[i + 1];
+            if (value) {
+                options.baseUrl = value;
+                i += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith("--baseUrl=")) {
+            options.baseUrl = arg.slice("--baseUrl=".length) || undefined;
+            continue;
+        }
+        if (arg === "--apiKey" || arg === "-k") {
+            const value = argv[i + 1];
+            if (value) {
+                options.apiKey = value;
+                i += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith("--apiKey=")) {
+            options.apiKey = arg.slice("--apiKey=".length) || undefined;
+            continue;
+        }
+    }
+    return options;
+};
+const cliOptions = parseCliArgs(process.argv.slice(2));
+const baseUrl = cliOptions.baseUrl ??
+    process.env.IOS_FARM_API_URL ??
+    "http://localhost:3000";
+const apiKey = cliOptions.apiKey ?? process.env.IOS_FARM_API_KEY;
+const client = new ApiClient(baseUrl, apiKey);
+const server = createServer(client);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/server.js

@@ -0,0 +1,55 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { accountsTools } from "./tools/accounts.js";
+import { scenariosTools } from "./tools/scenarios.js";
+const tools = [...accountsTools, ...scenariosTools];
+export function createServer(client) {
+    const server = new Server({
+        name: "farm-mcp",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: tools.map(({ name, description, inputSchema }) => ({
+                name,
+                description,
+                inputSchema,
+            })),
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const toolName = request.params.name;
+        const tool = tools.find(item => item.name === toolName);
+        if (!tool) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        try {
+            const result = await tool.handler(client, request.params.arguments ?? {});
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result ?? { success: true }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: false, error: message }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}

package/dist/tools/accounts.js

@@ -0,0 +1,155 @@
+import { z } from "zod";
+const registerSchema = z.object({
+    platform: z.string(),
+    username: z.string(),
+    deviceId: z.string(),
+    metadata: z.record(z.unknown()).optional(),
+});
+const listSchema = z.object({
+    platform: z.string().optional(),
+});
+const getSchema = z.object({
+    id: z.string(),
+});
+const getByUsernameSchema = z.object({
+    platform: z.string(),
+    username: z.string(),
+});
+const getByDeviceSchema = z.object({
+    deviceId: z.string(),
+});
+const updateSchema = z.object({
+    id: z.string(),
+    username: z.string().optional(),
+    deviceId: z.string().optional(),
+    metadata: z.record(z.unknown()).optional(),
+});
+const deleteSchema = z.object({
+    id: z.string(),
+});
+const accountHandlers = {
+    async register(client, args) {
+        const input = registerSchema.parse(args);
+        return client.request("POST", "/accounts", input);
+    },
+    async list(client, args) {
+        const input = listSchema.parse(args);
+        const query = input.platform
+            ? `?platform=${encodeURIComponent(input.platform)}`
+            : "";
+        return client.request("GET", `/accounts${query}`);
+    },
+    async get(client, args) {
+        const input = getSchema.parse(args);
+        return client.request("GET", `/accounts/${encodeURIComponent(input.id)}`);
+    },
+    async getByUsername(client, args) {
+        const input = getByUsernameSchema.parse(args);
+        return client.request("GET", `/accounts/by-username/${encodeURIComponent(input.platform)}/${encodeURIComponent(input.username)}`);
+    },
+    async getByDevice(client, args) {
+        const input = getByDeviceSchema.parse(args);
+        return client.request("GET", `/accounts/by-device/${encodeURIComponent(input.deviceId)}`);
+    },
+    async update(client, args) {
+        const input = updateSchema.parse(args);
+        const { id, ...payload } = input;
+        return client.request("PUT", `/accounts/${encodeURIComponent(id)}`, payload);
+    },
+    async remove(client, args) {
+        const input = deleteSchema.parse(args);
+        return client.request("DELETE", `/accounts/${encodeURIComponent(input.id)}`);
+    },
+};
+export const accountsTools = [
+    {
+        name: "accounts_register",
+        description: "Register a new account",
+        inputSchema: {
+            type: "object",
+            properties: {
+                platform: { type: "string" },
+                username: { type: "string" },
+                deviceId: { type: "string" },
+                metadata: { type: "object", additionalProperties: true },
+            },
+            required: ["platform", "username", "deviceId"],
+        },
+        handler: accountHandlers.register,
+    },
+    {
+        name: "accounts_list",
+        description: "List accounts, optionally filtered by platform",
+        inputSchema: {
+            type: "object",
+            properties: {
+                platform: { type: "string" },
+            },
+        },
+        handler: accountHandlers.list,
+    },
+    {
+        name: "accounts_get",
+        description: "Get account by id",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+            },
+            required: ["id"],
+        },
+        handler: accountHandlers.get,
+    },
+    {
+        name: "accounts_get_by_username",
+        description: "Get account by platform and username",
+        inputSchema: {
+            type: "object",
+            properties: {
+                platform: { type: "string" },
+                username: { type: "string" },
+            },
+            required: ["platform", "username"],
+        },
+        handler: accountHandlers.getByUsername,
+    },
+    {
+        name: "accounts_get_by_device",
+        description: "Get accounts by device id",
+        inputSchema: {
+            type: "object",
+            properties: {
+                deviceId: { type: "string" },
+            },
+            required: ["deviceId"],
+        },
+        handler: accountHandlers.getByDevice,
+    },
+    {
+        name: "accounts_update",
+        description: "Update account fields",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+                username: { type: "string" },
+                deviceId: { type: "string" },
+                metadata: { type: "object", additionalProperties: true },
+            },
+            required: ["id"],
+        },
+        handler: accountHandlers.update,
+    },
+    {
+        name: "accounts_delete",
+        description: "Delete account by id",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+            },
+            required: ["id"],
+        },
+        handler: accountHandlers.remove,
+    },
+];

package/dist/tools/scenarios.js

@@ -0,0 +1,219 @@
+import { z } from "zod";
+const uploadContentSchema = z.object({
+    accountIds: z.array(z.string()).min(1),
+    description: z.string(),
+    videoUrl: z.string().url(),
+});
+const carouselUploadSchema = z.object({
+    accountIds: z.array(z.string()).min(1),
+    description: z.string(),
+    imageUrls: z.array(z.string().url()).min(1),
+});
+const forYouWatchSchema = z.object({
+    accountIds: z.array(z.string()).min(1),
+    totalWatchTimeMin: z.number().optional(),
+    totalWatchTimeMax: z.number().optional(),
+    videoWatchTimeMin: z.number().optional(),
+    videoWatchTimeMax: z.number().optional(),
+    likePercentage: z.number().optional(),
+    profileParams: z
+        .object({
+        percentage: z.number().optional(),
+        minDepth: z.number().optional(),
+        maxDepth: z.number().optional(),
+    })
+        .optional(),
+});
+const searchAndWatchSchema = forYouWatchSchema.extend({
+    keyword: z.string(),
+});
+const profileWatchSchema = forYouWatchSchema.extend({
+    profiles: z.array(z.string()).min(1),
+});
+const likeSchema = z.object({
+    accountId: z.string(),
+});
+const taskSchema = z.object({
+    taskId: z.string(),
+});
+const scenarioHandlers = {
+    async uploadContent(client, args) {
+        const input = uploadContentSchema.parse(args);
+        return client.request("POST", "/scenarios/upload", input);
+    },
+    async carouselUpload(client, args) {
+        const input = carouselUploadSchema.parse(args);
+        return client.request("POST", "/scenarios/carousel-upload", input);
+    },
+    async forYouWatch(client, args) {
+        const input = forYouWatchSchema.parse(args);
+        return client.request("POST", "/scenarios/for-you-watch", input);
+    },
+    async searchAndWatch(client, args) {
+        const input = searchAndWatchSchema.parse(args);
+        return client.request("POST", "/scenarios/search-and-watch", input);
+    },
+    async profileWatch(client, args) {
+        const input = profileWatchSchema.parse(args);
+        return client.request("POST", "/scenarios/profile-watch", input);
+    },
+    async like(client, args) {
+        const input = likeSchema.parse(args);
+        return client.request("POST", "/scenarios/like", input);
+    },
+    async getTask(client, args) {
+        const input = taskSchema.parse(args);
+        return client.request("GET", `/scenarios/task/${encodeURIComponent(input.taskId)}`);
+    },
+    async cancelTask(client, args) {
+        const input = taskSchema.parse(args);
+        return client.request("POST", `/scenarios/task/${encodeURIComponent(input.taskId)}/cancel`);
+    },
+};
+export const scenariosTools = [
+    {
+        name: "scenarios_upload_content",
+        description: "Upload content to platform using videoUrl",
+        inputSchema: {
+            type: "object",
+            properties: {
+                accountIds: { type: "array", items: { type: "string" } },
+                description: { type: "string" },
+                videoUrl: { type: "string", format: "uri" },
+            },
+            required: ["accountIds", "description", "videoUrl"],
+        },
+        handler: scenarioHandlers.uploadContent,
+    },
+    {
+        name: "scenarios_carousel_upload",
+        description: "Upload image carousel using imageUrls",
+        inputSchema: {
+            type: "object",
+            properties: {
+                accountIds: { type: "array", items: { type: "string" } },
+                description: { type: "string" },
+                imageUrls: {
+                    type: "array",
+                    items: { type: "string", format: "uri" },
+                },
+            },
+            required: ["accountIds", "description", "imageUrls"],
+        },
+        handler: scenarioHandlers.carouselUpload,
+    },
+    {
+        name: "scenarios_for_you_watch",
+        description: "Watch For You feed with optional parameters",
+        inputSchema: {
+            type: "object",
+            properties: {
+                accountIds: { type: "array", items: { type: "string" } },
+                totalWatchTimeMin: { type: "number" },
+                totalWatchTimeMax: { type: "number" },
+                videoWatchTimeMin: { type: "number" },
+                videoWatchTimeMax: { type: "number" },
+                likePercentage: { type: "number" },
+                profileParams: {
+                    type: "object",
+                    properties: {
+                        percentage: { type: "number" },
+                        minDepth: { type: "number" },
+                        maxDepth: { type: "number" },
+                    },
+                },
+            },
+            required: ["accountIds"],
+        },
+        handler: scenarioHandlers.forYouWatch,
+    },
+    {
+        name: "scenarios_search_and_watch",
+        description: "Search by keyword and watch videos",
+        inputSchema: {
+            type: "object",
+            properties: {
+                accountIds: { type: "array", items: { type: "string" } },
+                keyword: { type: "string" },
+                totalWatchTimeMin: { type: "number" },
+                totalWatchTimeMax: { type: "number" },
+                videoWatchTimeMin: { type: "number" },
+                videoWatchTimeMax: { type: "number" },
+                likePercentage: { type: "number" },
+                profileParams: {
+                    type: "object",
+                    properties: {
+                        percentage: { type: "number" },
+                        minDepth: { type: "number" },
+                        maxDepth: { type: "number" },
+                    },
+                },
+            },
+            required: ["accountIds", "keyword"],
+        },
+        handler: scenarioHandlers.searchAndWatch,
+    },
+    {
+        name: "scenarios_profile_watch",
+        description: "Open profiles and watch their videos",
+        inputSchema: {
+            type: "object",
+            properties: {
+                accountIds: { type: "array", items: { type: "string" } },
+                profiles: { type: "array", items: { type: "string" } },
+                totalWatchTimeMin: { type: "number" },
+                totalWatchTimeMax: { type: "number" },
+                videoWatchTimeMin: { type: "number" },
+                videoWatchTimeMax: { type: "number" },
+                likePercentage: { type: "number" },
+                profileParams: {
+                    type: "object",
+                    properties: {
+                        percentage: { type: "number" },
+                        minDepth: { type: "number" },
+                        maxDepth: { type: "number" },
+                    },
+                    required: ["percentage", "minDepth", "maxDepth"],
+                },
+            },
+            required: ["accountIds", "profiles", "profileParams"],
+        },
+        handler: scenarioHandlers.profileWatch,
+    },
+    {
+        name: "scenarios_like",
+        description: "Like current content",
+        inputSchema: {
+            type: "object",
+            properties: {
+                accountId: { type: "string" },
+            },
+            required: ["accountId"],
+        },
+        handler: scenarioHandlers.like,
+    },
+    {
+        name: "scenarios_get_task",
+        description: "Get task status by taskId",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskId: { type: "string" },
+            },
+            required: ["taskId"],
+        },
+        handler: scenarioHandlers.getTask,
+    },
+    {
+        name: "scenarios_cancel_task",
+        description: "Cancel task by taskId",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskId: { type: "string" },
+            },
+            required: ["taskId"],
+        },
+        handler: scenarioHandlers.cancelTask,
+    },
+];

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@n0ml1/farm-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for iOS Farm accounts and scenarios",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "farm-mcp": "dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "n0ml1",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "dotenv": "^17.2.3",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "debug": "tsx --inspect-brk=9229 src/index.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "start": "node dist/index.js"
+  }
+}