@praise25/meta-mcp-server 0.1.0

package/dist/tools/meta/graph-read.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { MetaError } from "../../errors.js";
+import { jsonBlock, toolError, toolResult } from "../../helpers/format.js";
+const paramsRecord = z
+    .record(z.union([z.string(), z.number(), z.boolean()]))
+    .optional()
+    .describe("Query parameters. `access_token` and `appsecret_proof` are added automatically and must not be supplied here.");
+export const inputSchema = z
+    .object({
+    path: z
+        .string()
+        .min(1)
+        .describe("Graph API path after the version segment. Examples: 'me/businesses', 'act_1234567890/insights', '100000012345/posts'. Do NOT include a leading 'v23.0/' — the configured API version is added automatically."),
+    params: paramsRecord,
+    api_version: z
+        .string()
+        .regex(/^v\d+\.\d+$/)
+        .optional()
+        .describe("Override the Graph API version for this call, e.g. 'v20.0'. Defaults to the configured version."),
+})
+    .strict();
+const FORBIDDEN_PARAMS = new Set(["access_token", "appsecret_proof"]);
+export const definition = {
+    name: "meta_graph_read",
+    title: "Arbitrary read-only Graph API call",
+    description: `Escape-hatch for arbitrary GET requests against the Meta Graph API.
+
+This tool exists so the assistant can reach fields and endpoints that do not yet have a dedicated tool wrapper — without ever sending a write. The underlying HTTP client is hard-wired to GET only; POST/PUT/DELETE are refused before the request leaves the process.
+
+Rules:
+- Do NOT include 'access_token' or 'appsecret_proof' in params — they are added automatically.
+- Do NOT prefix the path with the API version.
+- Prefer dedicated tools (meta_business_list_assets, meta_ads_get_insights, …) when they exist. Use this as a last resort.`,
+    inputSchema: inputSchema.shape,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+};
+export async function handler(input, ctx) {
+    for (const k of Object.keys(input.params ?? {})) {
+        if (FORBIDDEN_PARAMS.has(k)) {
+            return toolError(`Parameter '${k}' must not be supplied — the server adds it automatically.`, "Remove it from the params object and retry.");
+        }
+    }
+    try {
+        const data = await ctx.graph.get({
+            path: input.path,
+            params: input.params,
+            apiVersion: input.api_version,
+        });
+        const structured = {
+            path: input.path,
+            api_version: input.api_version ?? ctx.config.apiVersion,
+            data,
+        };
+        return toolResult(structured, jsonBlock(data));
+    }
+    catch (err) {
+        const e = err instanceof MetaError ? err : new MetaError(err.message);
+        return toolError(e.message, e.hint, {
+            code: e.code,
+            subcode: e.subcode,
+            fbtrace_id: e.fbtraceId,
+            http_status: e.httpStatus,
+            path: input.path,
+        });
+    }
+}

package/dist/tools/overview/business-overview.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    business_id: z.ZodString;
+    date_preset: z.ZodDefault<z.ZodEnum<["today", "yesterday", "this_month", "last_month", "this_quarter", "maximum", "last_3d", "last_7d", "last_14d", "last_28d", "last_30d", "last_90d", "last_week_mon_sun", "last_week_sun_sat", "last_quarter", "last_year", "this_week_mon_today", "this_week_sun_today", "this_year"]>>;
+    include_pixels: z.ZodDefault<z.ZodBoolean>;
+    include_catalogs: z.ZodDefault<z.ZodBoolean>;
+    include_whatsapp: z.ZodDefault<z.ZodBoolean>;
+    max_ad_accounts: z.ZodDefault<z.ZodNumber>;
+    max_pages: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    business_id: string;
+    date_preset: "today" | "yesterday" | "this_month" | "last_month" | "this_quarter" | "maximum" | "last_3d" | "last_7d" | "last_14d" | "last_28d" | "last_30d" | "last_90d" | "last_week_mon_sun" | "last_week_sun_sat" | "last_quarter" | "last_year" | "this_week_mon_today" | "this_week_sun_today" | "this_year";
+    include_pixels: boolean;
+    include_catalogs: boolean;
+    include_whatsapp: boolean;
+    max_ad_accounts: number;
+    max_pages: number;
+}, {
+    business_id: string;
+    date_preset?: "today" | "yesterday" | "this_month" | "last_month" | "this_quarter" | "maximum" | "last_3d" | "last_7d" | "last_14d" | "last_28d" | "last_30d" | "last_90d" | "last_week_mon_sun" | "last_week_sun_sat" | "last_quarter" | "last_year" | "this_week_mon_today" | "this_week_sun_today" | "this_year" | undefined;
+    include_pixels?: boolean | undefined;
+    include_catalogs?: boolean | undefined;
+    include_whatsapp?: boolean | undefined;
+    max_ad_accounts?: number | undefined;
+    max_pages?: number | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_business_overview";
+    readonly title: "Eagle's-eye snapshot of a business";
+    readonly description: "One-call consolidated read across the whole Meta surface for a business:\n\n- Identity (system user + token app)\n- Assigned Pages + each Page's high-level insights (impressions, engagement, fans) for the requested window\n- Instagram Business accounts linked to those Pages (followers, media_count)\n- Owned + client ad accounts with balance, spend cap, amount spent, and last-window insights (spend, impressions, clicks, CTR, CPC, reach)\n- Pixels with last_fired_time (if include_pixels)\n- Catalogs with product counts (if include_catalogs)\n- WhatsApp Business Accounts + phone numbers (if include_whatsapp)\n\nEach section has its own error isolation — one failing asset does not kill the report. Ideal as the opening call for any AI-driven marketing insights conversation.";
+    readonly inputSchema: {
+        business_id: z.ZodString;
+        date_preset: z.ZodDefault<z.ZodEnum<["today", "yesterday", "this_month", "last_month", "this_quarter", "maximum", "last_3d", "last_7d", "last_14d", "last_28d", "last_30d", "last_90d", "last_week_mon_sun", "last_week_sun_sat", "last_quarter", "last_year", "this_week_mon_today", "this_week_sun_today", "this_year"]>>;
+        include_pixels: z.ZodDefault<z.ZodBoolean>;
+        include_catalogs: z.ZodDefault<z.ZodBoolean>;
+        include_whatsapp: z.ZodDefault<z.ZodBoolean>;
+        max_ad_accounts: z.ZodDefault<z.ZodNumber>;
+        max_pages: z.ZodDefault<z.ZodNumber>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/overview/business-overview.js

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { MetaError } from "../../errors.js";
+import { jsonBlock, toolResult } from "../../helpers/format.js";
+import { datePresetSchema, metaIdSchema } from "../../helpers/schema.js";
+export const inputSchema = z
+    .object({
+    business_id: metaIdSchema.describe("Business Manager ID."),
+    date_preset: datePresetSchema
+        .default("last_30d")
+        .describe("Date window used for ad account and page insights snapshots."),
+    include_pixels: z.boolean().default(true),
+    include_catalogs: z.boolean().default(true),
+    include_whatsapp: z.boolean().default(true),
+    max_ad_accounts: z.number().int().min(1).max(50).default(10).describe("Cap on number of ad accounts to fetch insights for. Each is one extra Graph call — tune for rate limits."),
+    max_pages: z.number().int().min(1).max(50).default(10).describe("Cap on number of Pages to fetch insights for."),
+})
+    .strict();
+export const definition = {
+    name: "meta_business_overview",
+    title: "Eagle's-eye snapshot of a business",
+    description: `One-call consolidated read across the whole Meta surface for a business:
+
+- Identity (system user + token app)
+- Assigned Pages + each Page's high-level insights (impressions, engagement, fans) for the requested window
+- Instagram Business accounts linked to those Pages (followers, media_count)
+- Owned + client ad accounts with balance, spend cap, amount spent, and last-window insights (spend, impressions, clicks, CTR, CPC, reach)
+- Pixels with last_fired_time (if include_pixels)
+- Catalogs with product counts (if include_catalogs)
+- WhatsApp Business Accounts + phone numbers (if include_whatsapp)
+
+Each section has its own error isolation — one failing asset does not kill the report. Ideal as the opening call for any AI-driven marketing insights conversation.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+function ok(data) {
+    return { ok: true, data };
+}
+function fail(err) {
+    const e = err instanceof MetaError ? err : new MetaError(err.message);
+    return { ok: false, error: e.message, hint: e.hint };
+}
+export async function handler(input, ctx) {
+    assertAllowed("business", input.business_id, ctx.config);
+    const started = Date.now();
+    const token = ctx.graph.get({
+        path: "debug_token",
+        params: { input_token: ctx.config.accessToken },
+        noCache: true,
+    }).then((r) => ok(r.data)).catch(fail);
+    const identity = ctx.graph.get({ path: "me", params: { fields: "id,name" } })
+        .then(ok)
+        .catch(fail);
+    const pages = ctx.graph
+        .get({
+        path: "me/assigned_pages",
+        params: { fields: "id,name,category,fan_count,followers_count", limit: input.max_pages },
+    })
+        .then(ok)
+        .catch(fail);
+    const ownedAds = ctx.graph
+        .get({
+        path: `${input.business_id}/owned_ad_accounts`,
+        params: { fields: "id,account_id,name,currency,account_status,amount_spent,balance,spend_cap", limit: input.max_ad_accounts },
+    })
+        .then(ok)
+        .catch(fail);
+    const clientAds = ctx.graph
+        .get({
+        path: `${input.business_id}/client_ad_accounts`,
+        params: { fields: "id,account_id,name,currency,account_status", limit: input.max_ad_accounts },
+    })
+        .then(ok)
+        .catch(fail);
+    const pixels = input.include_pixels
+        ? ctx.graph
+            .get({
+            path: `${input.business_id}/owned_pixels`,
+            params: { fields: "id,name,last_fired_time,is_unavailable", limit: 25 },
+        })
+            .then(ok)
+            .catch(fail)
+        : Promise.resolve(ok({ skipped: true }));
+    const catalogs = input.include_catalogs
+        ? ctx.graph
+            .get({
+            path: `${input.business_id}/owned_product_catalogs`,
+            params: { fields: "id,name,vertical,product_count", limit: 25 },
+        })
+            .then(ok)
+            .catch(fail)
+        : Promise.resolve(ok({ skipped: true }));
+    const wabas = input.include_whatsapp
+        ? ctx.graph
+            .get({
+            path: `${input.business_id}/owned_whatsapp_business_accounts`,
+            params: { fields: "id,name,currency,status,business_verification_status", limit: 25 },
+        })
+            .then(ok)
+            .catch(fail)
+        : Promise.resolve(ok({ skipped: true }));
+    const [identityR, tokenR, pagesR, ownedAdsR, clientAdsR, pixelsR, catalogsR, wabasR] = await Promise.all([
+        identity,
+        token,
+        pages,
+        ownedAds,
+        clientAds,
+        pixels,
+        catalogs,
+        wabas,
+    ]);
+    // Expand each page with linked IG + a small insights fetch.
+    const pagesExpanded = pagesR.ok && pagesR.data.data
+        ? await Promise.all(pagesR.data.data.map(async (p) => {
+            const [igR, insightsR] = await Promise.all([
+                ctx.graph
+                    .get({
+                    path: p.id,
+                    params: { fields: "instagram_business_account{id,username,name,followers_count,media_count}" },
+                })
+                    .then(ok)
+                    .catch(fail),
+                ctx.graph
+                    .get({
+                    path: `${p.id}/insights`,
+                    params: {
+                        // Narrow v23-safe metric set; requires 'read_insights' scope.
+                        metric: "page_impressions,page_post_engagements,page_fans,page_views_total",
+                        date_preset: input.date_preset,
+                    },
+                })
+                    .then(ok)
+                    .catch(fail),
+            ]);
+            return {
+                id: p.id,
+                name: p.name,
+                category: p.category,
+                fan_count: p.fan_count,
+                followers_count: p.followers_count,
+                instagram: igR.ok ? igR.data.instagram_business_account ?? null : { error: igR.error, hint: igR.hint },
+                insights_last_window: insightsR.ok ? insightsR.data.data ?? [] : { error: insightsR.error, hint: insightsR.hint },
+            };
+        }))
+        : [];
+    // Same treatment for ad accounts.
+    const adAccountsData = [
+        ...((ownedAdsR.ok && ownedAdsR.data.data) ? ownedAdsR.data.data.map((a) => ({ ...a, scope: "owned" })) : []),
+        ...((clientAdsR.ok && clientAdsR.data.data) ? clientAdsR.data.data.map((a) => ({ ...a, scope: "client" })) : []),
+    ].slice(0, input.max_ad_accounts);
+    const adAccountsExpanded = await Promise.all(adAccountsData.map(async (a) => {
+        const insightsR = await ctx.graph
+            .get({
+            path: `${a.id}/insights`,
+            params: {
+                level: "account",
+                fields: "spend,impressions,reach,frequency,clicks,ctr,cpc,cpm,actions",
+                date_preset: input.date_preset,
+            },
+        })
+            .then(ok)
+            .catch(fail);
+        return {
+            id: a.id,
+            account_id: a.account_id,
+            name: a.name,
+            scope: a.scope,
+            currency: a.currency,
+            account_status: a.account_status,
+            insights_last_window: insightsR.ok ? insightsR.data.data?.[0] ?? null : { error: insightsR.error, hint: insightsR.hint },
+        };
+    }));
+    const structured = {
+        business_id: input.business_id,
+        date_preset: input.date_preset,
+        generated_at: new Date().toISOString(),
+        latency_ms: Date.now() - started,
+        identity: identityR,
+        token: tokenR,
+        pages: pagesExpanded,
+        ad_accounts: adAccountsExpanded,
+        pixels: pixelsR,
+        catalogs: catalogsR,
+        whatsapp: wabasR,
+        rate_limit_after: ctx.graph.rateLimit,
+    };
+    return toolResult(structured, jsonBlock(structured));
+}

package/dist/tools/pages/get-insights.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    page_id: z.ZodString;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    period: z.ZodDefault<z.ZodEnum<["day", "week", "days_28", "lifetime", "total_over_range"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    page_id: string;
+    metrics: string[];
+    period: "day" | "week" | "days_28" | "lifetime" | "total_over_range";
+    since?: string | undefined;
+    until?: string | undefined;
+}, {
+    page_id: string;
+    since?: string | undefined;
+    until?: string | undefined;
+    metrics?: string[] | undefined;
+    period?: "day" | "week" | "days_28" | "lifetime" | "total_over_range" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_get_insights";
+    readonly title: "Get Page-level insights";
+    readonly description: "Reads Page-level metrics: impressions, reach, engagements, fan growth, page views, video views. Requires 'read_insights' scope. Pick the right period per metric — many accept only 'day' or 'days_28'.";
+    readonly inputSchema: {
+        page_id: z.ZodString;
+        metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        period: z.ZodDefault<z.ZodEnum<["day", "week", "days_28", "lifetime", "total_over_range"]>>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/get-insights.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+const PERIOD = z.enum(["day", "week", "days_28", "lifetime", "total_over_range"]);
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    metrics: z
+        .array(z.string())
+        .default([
+        // Metrics that Meta still supports as of v23 (2026).
+        // Several 2023/2024 deprecations removed: page_consumptions, page_fan_removes,
+        // page_actions_post_reactions_total, page_impressions_organic (use unique/paid combo instead).
+        "page_impressions",
+        "page_impressions_unique",
+        "page_impressions_paid",
+        "page_post_engagements",
+        "page_fans",
+        "page_fan_adds",
+        "page_views_total",
+        "page_video_views",
+        "page_video_views_paid",
+    ])
+        .describe("Page insight metrics. Not every metric supports every period — see https://developers.facebook.com/docs/graph-api/reference/v23.0/insights. Requires 'read_insights' scope."),
+    period: PERIOD.default("day"),
+    since: z.string().optional().describe("ISO date or Unix timestamp."),
+    until: z.string().optional().describe("ISO date or Unix timestamp."),
+})
+    .strict();
+export const definition = {
+    name: "meta_page_get_insights",
+    title: "Get Page-level insights",
+    description: `Reads Page-level metrics: impressions, reach, engagements, fan growth, page views, video views. Requires 'read_insights' scope. Pick the right period per metric — many accept only 'day' or 'days_28'.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runGet(ctx, {
+        path: `${input.page_id}/insights`,
+        params: {
+            metric: input.metrics.join(","),
+            period: input.period,
+            since: input.since,
+            until: input.until,
+        },
+    });
+}

package/dist/tools/pages/get-post-insights.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    post_id: z.ZodString;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    post_id: string;
+    metrics: string[];
+}, {
+    post_id: string;
+    metrics?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_get_post_insights";
+    readonly title: "Get insights for a single Page post";
+    readonly description: "Reads impressions, unique reach, paid vs. organic split, engaged users, click counts, reactions-by-type, and video view metrics for a single post. Requires 'read_insights' scope.";
+    readonly inputSchema: {
+        post_id: z.ZodString;
+        metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/get-post-insights.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+export const inputSchema = z
+    .object({
+    post_id: metaIdSchema.describe("Post ID (format '{page_id}_{post_id}' or shortform)."),
+    metrics: z
+        .array(z.string())
+        .default([
+        "post_impressions",
+        "post_impressions_unique",
+        "post_impressions_paid",
+        "post_impressions_organic",
+        "post_engaged_users",
+        "post_clicks",
+        "post_reactions_by_type_total",
+        "post_video_views",
+        "post_video_views_unique",
+        "post_video_avg_time_watched",
+    ])
+        .describe("Post-level insight metrics. See https://developers.facebook.com/docs/graph-api/reference/v23.0/insights"),
+})
+    .strict();
+export const definition = {
+    name: "meta_page_get_post_insights",
+    title: "Get insights for a single Page post",
+    description: `Reads impressions, unique reach, paid vs. organic split, engaged users, click counts, reactions-by-type, and video view metrics for a single post. Requires 'read_insights' scope.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    return runGet(ctx, {
+        path: `${input.post_id}/insights`,
+        params: { metric: input.metrics.join(",") },
+    });
+}

package/dist/tools/pages/get.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    page_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    page_id: string;
+}, {
+    page_id: string;
+    fields?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_get";
+    readonly title: "Get Page details";
+    readonly description: "Full page profile snapshot: category, about, fan count, rating, engagement, linked IG Business account, cover/picture. Use as the 'know-your-page' call before fetching posts or insights.";
+    readonly inputSchema: {
+        page_id: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/get.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "username",
+        "category",
+        "category_list",
+        "about",
+        "description",
+        "fan_count",
+        "followers_count",
+        "verification_status",
+        "rating_count",
+        "overall_star_rating",
+        "link",
+        "website",
+        "phone",
+        "emails",
+        "location",
+        "single_line_address",
+        "engagement",
+        "talking_about_count",
+        "were_here_count",
+        "checkins",
+        "cover",
+        "picture.type(large)",
+        "instagram_business_account{id,username,name}",
+    ])
+        .describe("Page fields. Includes linked Instagram Business account when present."),
+})
+    .strict();
+export const definition = {
+    name: "meta_page_get",
+    title: "Get Page details",
+    description: `Full page profile snapshot: category, about, fan count, rating, engagement, linked IG Business account, cover/picture. Use as the 'know-your-page' call before fetching posts or insights.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runGet(ctx, { path: input.page_id, params: { fields: input.fields.join(",") } });
+}

package/dist/tools/pages/list-posts.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    page_id: z.ZodString;
+    edge: z.ZodDefault<z.ZodEnum<["posts", "published_posts", "feed"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    edge: "posts" | "published_posts" | "feed";
+    page_id: string;
+    since?: string | undefined;
+    until?: string | undefined;
+    after?: string | undefined;
+}, {
+    page_id: string;
+    since?: string | undefined;
+    until?: string | undefined;
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+    after?: string | undefined;
+    auto_paginate?: boolean | undefined;
+    edge?: "posts" | "published_posts" | "feed" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_list_posts";
+    readonly title: "List Page posts";
+    readonly description: "Lists Page posts with attached counts (reactions, comments, shares). Use since/until for a date window. The ID returned for each post is the one meta_page_get_post_insights expects.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        page_id: z.ZodString;
+        edge: z.ZodDefault<z.ZodEnum<["posts", "published_posts", "feed"]>>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/list-posts.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    edge: z
+        .enum(["posts", "published_posts", "feed"])
+        .default("published_posts")
+        .describe("'published_posts' is the standard edge. 'feed' includes user-posted items too."),
+    since: z.string().optional().describe("Unix timestamp or ISO date lower bound."),
+    until: z.string().optional().describe("Unix timestamp or ISO date upper bound."),
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "message",
+        "created_time",
+        "updated_time",
+        "permalink_url",
+        "status_type",
+        "type",
+        "is_published",
+        "from",
+        "attachments{media_type,title,url,subattachments}",
+        "reactions.summary(true).limit(0)",
+        "shares",
+        "comments.summary(true).limit(0)",
+    ])
+        .describe("Post fields. Default includes reaction + comment counts via summary."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_page_list_posts",
+    title: "List Page posts",
+    description: `Lists Page posts with attached counts (reactions, comments, shares). Use since/until for a date window. The ID returned for each post is the one meta_page_get_post_insights expects.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runList(ctx, {
+        path: `${input.page_id}/${input.edge}`,
+        params: {
+            fields: input.fields.join(","),
+            limit: input.limit,
+            after: input.after,
+            since: input.since,
+            until: input.until,
+        },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { page_id: input.page_id, edge: input.edge });
+}