@cmssy/mcp-server 0.16.2 → 0.17.0

package/dist/ai-tools-ops.js

@@ -1,4 +1,4 @@
-import { MODEL_DEFINITION_BY_ID_QUERY, MODEL_DEFINITIONS_BY_SLUG_INDEX_QUERY, CREATE_MODEL_RECORD_MUTATION, CREATE_DISCOUNT_MUTATION, SAVE_PAGE_MUTATION, CREATE_FORM_MUTATION, CREATE_MODEL_DEFINITION_MUTATION, UPDATE_MODEL_DEFINITION_MUTATION, MODEL_RECORD_BY_ID_QUERY, UPDATE_MODEL_RECORD_MUTATION, UPDATE_MODEL_RECORD_STATUS_MUTATION, } from "./queries.js";
+import { MODEL_DEFINITION_BY_ID_QUERY, MODEL_DEFINITIONS_BY_SLUG_INDEX_QUERY, MODEL_DEFINITIONS_QUERY, MODEL_RECORDS_QUERY, MEDIA_ASSETS_QUERY, FORMS_QUERY, ORDERS_QUERY, DISCOUNTS_QUERY, CREATE_MODEL_RECORD_MUTATION, CREATE_DISCOUNT_MUTATION, SAVE_PAGE_MUTATION, CREATE_FORM_MUTATION, CREATE_MODEL_DEFINITION_MUTATION, UPDATE_MODEL_DEFINITION_MUTATION, MODEL_RECORD_BY_ID_QUERY, UPDATE_MODEL_RECORD_MUTATION, UPDATE_MODEL_RECORD_STATUS_MUTATION, DELETE_MODEL_DEFINITION_MUTATION, DELETE_MODEL_RECORD_MUTATION, IMPORT_MODEL_RECORDS_MUTATION, PAGES_QUERY, PAGE_BY_ID_QUERY, PAGE_TYPES_QUERY, CREATE_PAGE_TYPE_MUTATION, UPDATE_PAGE_SETTINGS_MUTATION, UPDATE_PAGE_LAYOUT_MUTATION, PUBLISH_PAGE_CONTENT_MUTATION, PUBLISH_PAGE_LAYOUT_MUTATION, TOGGLE_PUBLISH_MUTATION, REVERT_CONTENT_TO_PUBLISHED_MUTATION, REVERT_LAYOUT_TO_PUBLISHED_MUTATION, REMOVE_PAGE_MUTATION, PATCH_BLOCK_CONTENT_MUTATION, SITE_CONFIG_QUERY, CURRENT_WORKSPACE_QUERY, FORM_BY_ID_QUERY, UPDATE_FORM_MUTATION, DELETE_FORM_MUTATION, FORM_SUBMISSIONS_QUERY, FORM_SUBMISSION_BY_ID_QUERY, UPDATE_FORM_SUBMISSION_STATUS_MUTATION, DELETE_FORM_SUBMISSION_MUTATION, ORDER_BY_ID_QUERY, ORDER_PIPELINE_QUERY, CREATE_MANUAL_ORDER_MUTATION, EDIT_ORDER_MUTATION, UPDATE_ORDER_DETAILS_MUTATION, MARK_ORDER_PAID_MUTATION, RECORD_ORDER_PAYMENT_MUTATION, REFUND_ORDER_MUTATION, CANCEL_ORDER_MUTATION, TRANSITION_ORDER_FULFILLMENT_MUTATION, SET_ORDER_PIPELINE_STAGE_MUTATION, RECORD_ORDER_INVOICE_MUTATION, DISCOUNT_BY_ID_QUERY, UPDATE_DISCOUNT_MUTATION, SET_DISCOUNT_ENABLED_MUTATION, WEBHOOK_ENDPOINTS_QUERY, WEBHOOK_DELIVERIES_QUERY, WEBHOOK_EVENT_TYPES_QUERY, CREATE_WEBHOOK_ENDPOINT_MUTATION, UPDATE_WEBHOOK_ENDPOINT_MUTATION, ROTATE_WEBHOOK_SECRET_MUTATION, DELETE_WEBHOOK_ENDPOINT_MUTATION, ADMIN_CARTS_QUERY, PRODUCT_CATALOG_QUERY, BULK_UPDATE_PRODUCT_RECORDS_MUTATION, BULK_DELETE_PRODUCT_RECORDS_MUTATION, } from "./queries.js";
 const OBJECT_ID_RE = /^[a-f0-9]{24}$/i;
 function slugify(value) {
     const slug = value
@@ -9,8 +9,21 @@ function slugify(value) {
         .replace(/^[0-9]/, "m$&");
     return slug || "model";
 }
-function notBound(name) {
-    throw new Error(`@cmssy/ai-tools op "${name}" is not bound on the MCP server yet`);
+const isEmpty = (obj) => obj == null ||
+    (typeof obj === "object" && Object.keys(obj).length === 0);
+function toRelativeSlug(slug) {
+    if (slug === "/")
+        return "/";
+    return "/" + slug.split("/").filter(Boolean).pop();
+}
+function expectedVersionOf(page) {
+    return page?.version != null ? Number(page.version) : undefined;
+}
+async function loadPage(client, pageId) {
+    const data = await client.query(PAGE_BY_ID_QUERY, {
+        pageId,
+    });
+    return data.page;
 }
 async function fetchModelById(client, id) {
     const data = await client.query(MODEL_DEFINITION_BY_ID_QUERY, { id });
@@ -34,12 +47,85 @@ async function resolveModel(client, idOrSlug) {
         return null;
     return fetchModelById(client, match.id);
 }
+function toModelSummary(m) {
+    return {
+        id: m.id,
+        name: m.name,
+        slug: m.slug,
+        description: m.description ?? null,
+        fieldCount: m.fields?.length ?? 0,
+    };
+}
+function toModelDetail(m) {
+    return {
+        id: m.id,
+        name: m.name,
+        slug: m.slug,
+        description: m.description ?? null,
+        displayField: m.displayField ?? null,
+        icon: m.icon ?? null,
+        color: m.color ?? null,
+        recordCount: m.recordCount ?? null,
+        defaultSort: m.defaultSort ?? null,
+        statusField: m.statusField
+            ? {
+                enabled: m.statusField.enabled,
+                values: m.statusField.values,
+                defaultValue: m.statusField.defaultValue ?? undefined,
+                transitions: m.statusField.transitions,
+            }
+            : null,
+        fields: (m.fields ?? []).map((f) => ({
+            key: f.key,
+            label: f.label,
+            type: f.type,
+            required: f.required ?? false,
+        })),
+    };
+}
 export function createMcpWorkspaceOps(client) {
+    const ws = client.workspaceId;
     return {
         models: {
-            list: () => notBound("models.list"),
-            get: () => notBound("models.get"),
-            listRecords: () => notBound("models.listRecords"),
+            list: async () => {
+                const res = await client.query(MODEL_DEFINITIONS_QUERY);
+                return res.modelDefinitions.map(toModelSummary);
+            },
+            get: async (idOrSlug) => {
+                const resolved = await resolveModel(client, idOrSlug);
+                if (!resolved)
+                    return null;
+                const res = await client.query(MODEL_DEFINITION_BY_ID_QUERY, { id: resolved.id });
+                if (!res.modelDefinition)
+                    return null;
+                return toModelDetail(res.modelDefinition);
+            },
+            listRecords: async (modelIdOrSlug, options) => {
+                const model = await resolveModel(client, modelIdOrSlug);
+                if (!model)
+                    return null;
+                const res = await client.query(MODEL_RECORDS_QUERY, {
+                    modelId: model.id,
+                    filter: options?.filter,
+                    sort: options?.sort,
+                    limit: options?.limit,
+                    offset: options?.offset,
+                    populate: options?.populate,
+                });
+                return {
+                    modelId: model.id,
+                    items: res.modelRecords.items.map((r) => ({
+                        id: r.id,
+                        modelId: r.modelId,
+                        status: r.status ?? null,
+                        data: r.data ?? {},
+                        createdAt: r.createdAt ?? null,
+                        updatedAt: r.updatedAt ?? null,
+                    })),
+                    total: res.modelRecords.total,
+                    hasMore: res.modelRecords.hasMore,
+                };
+            },
             create: async (input) => {
                 const mutationInput = {
                     name: input.name,
@@ -148,9 +234,51 @@ export function createMcpWorkspaceOps(client) {
                     modelId: model.id,
                 };
             },
+            getRecord: async (recordId) => {
+                const res = await client.query(MODEL_RECORD_BY_ID_QUERY, { id: recordId });
+                const r = res.modelRecord;
+                if (!r)
+                    return null;
+                return {
+                    id: r.id,
+                    modelId: r.modelId,
+                    status: r.status ?? null,
+                    data: r.data ?? {},
+                    createdAt: r.createdAt ?? null,
+                    updatedAt: r.updatedAt ?? null,
+                };
+            },
+            delete: async (idOrSlug) => {
+                const model = await resolveModel(client, idOrSlug);
+                if (!model)
+                    return { deleted: false };
+                const res = await client.query(DELETE_MODEL_DEFINITION_MUTATION, { id: model.id });
+                return { deleted: Boolean(res.deleteModelDefinition) };
+            },
+            deleteRecord: async (recordId) => {
+                const res = await client.query(DELETE_MODEL_RECORD_MUTATION, { id: recordId });
+                return { deleted: Boolean(res.deleteModelRecord) };
+            },
+            importRecords: async (modelIdOrSlug, rows) => {
+                const model = await resolveModel(client, modelIdOrSlug);
+                if (!model)
+                    throw new Error(`Model "${modelIdOrSlug}" not found`);
+                const res = await client.query(IMPORT_MODEL_RECORDS_MUTATION, {
+                    input: { modelId: model.id, rows },
+                });
+                return res.importModelRecords;
+            },
         },
         pages: {
-            search: () => notBound("pages.search"),
+            search: async (query) => {
+                const res = await client.query(PAGES_QUERY, { search: query });
+                return res.pages.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    slug: p.slug,
+                    published: p.published,
+                }));
+            },
             create: async (input) => {
                 const mutationInput = {
                     name: input.name,
@@ -173,10 +301,420 @@ export function createMcpWorkspaceOps(client) {
                 const res = await client.query(SAVE_PAGE_MUTATION, { input: mutationInput });
                 return { id: res.savePage.id, name: res.savePage.name };
             },
+            get: async (idOrSlug) => {
+                const page = await loadPage(client, idOrSlug);
+                if (!page)
+                    return null;
+                return {
+                    id: page.id,
+                    name: page.name,
+                    slug: page.slug,
+                    published: Boolean(page.published),
+                    pageType: page.pageType ?? null,
+                    parentId: page.parentId ?? null,
+                    blocks: page.blocks ?? null,
+                    layoutBlocks: page.layoutBlocks ?? null,
+                    customFields: page.customFields ?? null,
+                    createdAt: page.createdAt ?? null,
+                    updatedAt: page.updatedAt ?? null,
+                };
+            },
+            list: async (search) => {
+                const res = await client.query(PAGES_QUERY, search ? { search } : {});
+                return res.pages.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    slug: p.slug,
+                    published: Boolean(p.published),
+                }));
+            },
+            listTypes: async () => {
+                const res = await client.query(PAGE_TYPES_QUERY);
+                return res.pageTypes.map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    slug: t.slug,
+                    urlPrefix: t.urlPrefix ?? null,
+                    allowChildren: Boolean(t.allowChildren),
+                }));
+            },
+            updateBlocks: async (pageId, blocks) => {
+                const page = await loadPage(client, pageId);
+                if (!page)
+                    throw new Error("Page not found");
+                const existing = page.blocks ?? [];
+                const merged = blocks.map((block) => {
+                    const prev = existing.find((b) => b.id === block.id);
+                    if (!prev)
+                        return block;
+                    return {
+                        ...block,
+                        content: isEmpty(block.content) ? prev.content : block.content,
+                        settings: isEmpty(block.settings) ? prev.settings : block.settings,
+                        style: block.style ?? prev.style,
+                        advanced: block.advanced ?? prev.advanced,
+                        translations: isEmpty(block.translations)
+                            ? prev.translations
+                            : block.translations,
+                        defaultLanguage: block.defaultLanguage ?? prev.defaultLanguage,
+                        metadata: block.metadata ?? prev.metadata,
+                        blockVersion: block.blockVersion ?? prev.blockVersion,
+                    };
+                });
+                const res = await client.query(SAVE_PAGE_MUTATION, {
+                    input: {
+                        id: pageId,
+                        name: page.name,
+                        slug: toRelativeSlug(page.slug),
+                        parentId: page.parentId ?? undefined,
+                        blocks: merged,
+                        expectedVersion: expectedVersionOf(page),
+                    },
+                });
+                return { id: res.savePage.id };
+            },
+            updateSettings: async (pageId, settings) => {
+                const input = { id: pageId };
+                for (const key of [
+                    "name",
+                    "slug",
+                    "displayName",
+                    "seoTitle",
+                    "seoDescription",
+                    "seoKeywords",
+                    "customFields",
+                ]) {
+                    if (settings[key] !== undefined)
+                        input[key] = settings[key];
+                }
+                const res = await client.query(UPDATE_PAGE_SETTINGS_MUTATION, { input });
+                if (!res.updatePageSettings)
+                    throw new Error("Page not found");
+                return { id: res.updatePageSettings.id };
+            },
+            createType: async (input) => {
+                const mutationInput = {
+                    name: input.name,
+                    slug: input.slug,
+                };
+                if (input.description !== undefined)
+                    mutationInput.description = input.description;
+                if (input.icon !== undefined)
+                    mutationInput.icon = input.icon;
+                if (input.urlPrefix !== undefined)
+                    mutationInput.urlPrefix = input.urlPrefix;
+                if (input.allowChildren !== undefined)
+                    mutationInput.allowChildren = input.allowChildren;
+                if (input.fields !== undefined)
+                    mutationInput.fields = input.fields;
+                const res = await client.query(CREATE_PAGE_TYPE_MUTATION, { input: mutationInput });
+                return {
+                    id: res.createPageType.id,
+                    name: res.createPageType.name,
+                    slug: res.createPageType.slug,
+                };
+            },
+            publish: async (pageId) => {
+                const page = await client.query(PAGE_BY_ID_QUERY, { pageId });
+                if (!page.page)
+                    throw new Error("Page not found");
+                if (page.page.published &&
+                    !page.page.hasUnpublishedContentChanges &&
+                    !page.page.hasUnpublishedLayoutChanges) {
+                    return { id: pageId };
+                }
+                await client.query(PUBLISH_PAGE_CONTENT_MUTATION, { id: pageId });
+                let res;
+                try {
+                    res = await client.query(PUBLISH_PAGE_LAYOUT_MUTATION, { id: pageId });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    throw new Error(`Content published, but the layout axis failed and is still unpublished: ${message}. Note: re-running publish also re-publishes the current content draft, so publish any pending content edits first.`);
+                }
+                if (!res.publishPageLayout) {
+                    throw new Error("Content published, but the layout axis returned no result and is still unpublished. Note: re-running publish also re-publishes the current content draft, so publish any pending content edits first.");
+                }
+                return { id: res.publishPageLayout.id };
+            },
+            unpublish: async (pageId) => {
+                const res = await client.query(TOGGLE_PUBLISH_MUTATION, { id: pageId });
+                if (!res.togglePublish)
+                    throw new Error("Page not found");
+                return { id: res.togglePublish.id };
+            },
+            revert: async (pageId) => {
+                await client.query(REVERT_CONTENT_TO_PUBLISHED_MUTATION, {
+                    id: pageId,
+                });
+                await client.query(REVERT_LAYOUT_TO_PUBLISHED_MUTATION, { id: pageId });
+                return { id: pageId };
+            },
+            deletePage: async (pageId) => {
+                const res = await client.query(REMOVE_PAGE_MUTATION, { id: pageId });
+                return { deleted: Boolean(res.removePage) };
+            },
+            updateLayout: async (pageId, layout) => {
+                let mergedLayoutBlocks = layout.layoutBlocks;
+                if (layout.layoutBlocks) {
+                    const page = await loadPage(client, pageId);
+                    const existing = page?.layoutBlocks ?? [];
+                    mergedLayoutBlocks = layout.layoutBlocks.map((block) => {
+                        const prev = existing.find((b) => b.id === block.id);
+                        if (!prev)
+                            return block;
+                        return {
+                            ...block,
+                            content: isEmpty(block.content) ? prev.content : block.content,
+                            settings: isEmpty(block.settings)
+                                ? prev.settings
+                                : block.settings,
+                            translations: isEmpty(block.translations)
+                                ? prev.translations
+                                : block.translations,
+                        };
+                    });
+                }
+                const input = { pageId };
+                if (mergedLayoutBlocks !== undefined)
+                    input.layoutBlocks = mergedLayoutBlocks;
+                if (layout.layoutOverrides !== undefined)
+                    input.layoutOverrides = layout.layoutOverrides;
+                if (layout.inheritsLayout !== undefined)
+                    input.inheritsLayout = layout.inheritsLayout;
+                const res = await client.query(UPDATE_PAGE_LAYOUT_MUTATION, { input });
+                if (!res.updatePageLayout)
+                    throw new Error("Page not found");
+                return { id: res.updatePageLayout.id };
+            },
+            addBlock: async (pageId, block, layoutPosition, position) => {
+                const page = await loadPage(client, pageId);
+                if (!page)
+                    throw new Error("Page not found");
+                const configData = await client.query(SITE_CONFIG_QUERY);
+                const defaultLanguage = configData.siteConfig?.defaultLanguage ?? "en";
+                const enabledLanguages = configData.siteConfig?.enabledLanguages ?? [
+                    defaultLanguage,
+                ];
+                const content = block.content;
+                const translations = {};
+                for (const lang of enabledLanguages) {
+                    translations[lang] = {
+                        status: content[lang] ? "completed" : "pending",
+                    };
+                }
+                const newBlockId = crypto.randomUUID();
+                if (layoutPosition) {
+                    const existingLayout = page.layoutBlocks ?? [];
+                    const maxOrder = existingLayout
+                        .filter((b) => b.position === layoutPosition)
+                        .reduce((max, b) => Math.max(max, b.order ?? -1), -1);
+                    const newLayoutBlock = {
+                        id: newBlockId,
+                        type: block.type,
+                        position: layoutPosition,
+                        order: maxOrder + 1,
+                        isActive: true,
+                        content: block.content,
+                        settings: block.settings,
+                        style: block.style,
+                        translations,
+                        defaultLanguage,
+                    };
+                    const res = await client.query(UPDATE_PAGE_LAYOUT_MUTATION, {
+                        input: {
+                            pageId,
+                            layoutBlocks: [...existingLayout, newLayoutBlock],
+                        },
+                    });
+                    if (!res.updatePageLayout)
+                        throw new Error("Failed to add block");
+                    return { pageId, blockId: newBlockId };
+                }
+                const newBlock = {
+                    id: newBlockId,
+                    type: block.type,
+                    content: block.content,
+                    settings: block.settings,
+                    style: block.style,
+                    translations,
+                    defaultLanguage,
+                };
+                const blocks = [...(page.blocks ?? [])];
+                if (position !== undefined &&
+                    position >= 0 &&
+                    position < blocks.length) {
+                    blocks.splice(position, 0, newBlock);
+                }
+                else {
+                    blocks.push(newBlock);
+                }
+                await client.query(SAVE_PAGE_MUTATION, {
+                    input: {
+                        id: pageId,
+                        name: page.name,
+                        slug: toRelativeSlug(page.slug),
+                        parentId: page.parentId ?? undefined,
+                        blocks,
+                        expectedVersion: expectedVersionOf(page),
+                    },
+                });
+                return { pageId, blockId: newBlockId };
+            },
+            updateBlock: async (pageId, blockId, content, settings) => {
+                const page = await loadPage(client, pageId);
+                if (!page)
+                    throw new Error("Page not found");
+                const contentIdx = (page.blocks ?? []).findIndex((b) => b.id === blockId);
+                const layoutIdx = contentIdx === -1
+                    ? (page.layoutBlocks ?? []).findIndex((b) => b.id === blockId)
+                    : -1;
+                if (contentIdx === -1 && layoutIdx === -1) {
+                    throw new Error("Block not found on page");
+                }
+                const isLayout = layoutIdx !== -1;
+                const targetArray = isLayout
+                    ? [...(page.layoutBlocks ?? [])]
+                    : [...(page.blocks ?? [])];
+                const targetIndex = isLayout ? layoutIdx : contentIdx;
+                const existingBlock = {
+                    ...targetArray[targetIndex],
+                };
+                const mergedContent = {
+                    ...(existingBlock.content ?? {}),
+                };
+                for (const [lang, langContent] of Object.entries(content)) {
+                    if (typeof langContent === "object" &&
+                        langContent !== null &&
+                        typeof mergedContent[lang] === "object" &&
+                        mergedContent[lang] !== null) {
+                        mergedContent[lang] = {
+                            ...mergedContent[lang],
+                            ...langContent,
+                        };
+                    }
+                    else {
+                        mergedContent[lang] = langContent;
+                    }
+                }
+                existingBlock.content = mergedContent;
+                if (settings) {
+                    existingBlock.settings = {
+                        ...(existingBlock.settings ?? {}),
+                        ...settings,
+                    };
+                }
+                const trans = existingBlock.translations;
+                if (trans) {
+                    for (const lang of Object.keys(content)) {
+                        if (trans[lang])
+                            trans[lang] = { status: "completed" };
+                    }
+                }
+                targetArray[targetIndex] = existingBlock;
+                if (isLayout) {
+                    const res = await client.query(UPDATE_PAGE_LAYOUT_MUTATION, {
+                        input: { pageId, layoutBlocks: targetArray },
+                    });
+                    if (!res.updatePageLayout)
+                        throw new Error("Failed to update block");
+                }
+                else {
+                    await client.query(SAVE_PAGE_MUTATION, {
+                        input: {
+                            id: pageId,
+                            name: page.name,
+                            slug: toRelativeSlug(page.slug),
+                            parentId: page.parentId ?? undefined,
+                            blocks: targetArray,
+                            expectedVersion: expectedVersionOf(page),
+                        },
+                    });
+                }
+                return { pageId, blockId };
+            },
+            patchBlock: async (pageId, blockId, locale, operations, fieldPath, expectedVersion) => {
+                const res = await client.query(PATCH_BLOCK_CONTENT_MUTATION, {
+                    input: {
+                        pageId,
+                        blockId,
+                        locale,
+                        ...(fieldPath ? { fieldPath } : {}),
+                        ...(expectedVersion !== undefined ? { expectedVersion } : {}),
+                        operations,
+                    },
+                });
+                if (!res.patchBlockContent) {
+                    throw new Error("Page not found or patch failed");
+                }
+                return { pageId, blockId };
+            },
+            removeBlock: async (pageId, blockId) => {
+                const page = await loadPage(client, pageId);
+                if (!page)
+                    throw new Error("Page not found");
+                const contentBlocks = (page.blocks ?? []).filter((b) => b.id !== blockId);
+                if (contentBlocks.length < (page.blocks ?? []).length) {
+                    await client.query(SAVE_PAGE_MUTATION, {
+                        input: {
+                            id: pageId,
+                            name: page.name,
+                            slug: toRelativeSlug(page.slug),
+                            parentId: page.parentId ?? undefined,
+                            blocks: contentBlocks,
+                            expectedVersion: expectedVersionOf(page),
+                        },
+                    });
+                    return { pageId, blockId };
+                }
+                const layoutBlocks = (page.layoutBlocks ?? []).filter((b) => b.id !== blockId);
+                if (layoutBlocks.length < (page.layoutBlocks ?? []).length) {
+                    const res = await client.query(UPDATE_PAGE_LAYOUT_MUTATION, {
+                        input: { pageId, layoutBlocks },
+                    });
+                    if (!res.updatePageLayout)
+                        throw new Error("Failed to remove block");
+                    return { pageId, blockId };
+                }
+                throw new Error("Block not found on page");
+            },
+        },
+        media: {
+            list: async (limit, offset) => {
+                const res = await client.query(MEDIA_ASSETS_QUERY, { limit, offset });
+                return {
+                    items: res.mediaAssets.items.map((m) => ({
+                        id: m.id,
+                        filename: m.filename,
+                        type: m.type,
+                        url: m.url ?? null,
+                        mimeType: m.mimeType ?? null,
+                        size: m.size ?? null,
+                    })),
+                    total: res.mediaAssets.total,
+                    hasMore: res.mediaAssets.hasMore,
+                };
+            },
         },
-        media: { list: () => notBound("media.list") },
         forms: {
-            list: () => notBound("forms.list"),
+            list: async (options) => {
+                const res = await client.query(FORMS_QUERY, {
+                    status: options?.status,
+                    skip: options?.skip,
+                    limit: options?.limit,
+                });
+                return {
+                    items: res.forms.forms.map((f) => ({
+                        id: f.id,
+                        name: f.name,
+                        slug: f.slug ?? null,
+                        status: f.status,
+                        submissionCount: f.submissionCount ?? null,
+                    })),
+                    total: res.forms.total,
+                    hasMore: res.forms.hasMore,
+                };
+            },
             create: async (input) => {
                 const mutationInput = {
                     name: input.name,
@@ -191,17 +729,389 @@ export function createMcpWorkspaceOps(client) {
                 const res = await client.query(CREATE_FORM_MUTATION, { input: mutationInput });
                 return { id: res.createForm.id, name: res.createForm.name };
             },
+            get: async (idOrSlug) => {
+                const res = await client.query(FORM_BY_ID_QUERY, { formId: idOrSlug });
+                const f = res.form;
+                if (!f)
+                    return null;
+                return {
+                    id: f.id,
+                    name: f.name,
+                    slug: f.slug,
+                    status: f.status ?? null,
+                    fields: f.fields ?? null,
+                    settings: f.settings ?? null,
+                    submissionCount: f.submissionCount ?? null,
+                };
+            },
+            update: async (idOrSlug, patch) => {
+                const input = {};
+                for (const key of [
+                    "name",
+                    "slug",
+                    "description",
+                    "status",
+                    "fields",
+                    "settings",
+                ]) {
+                    if (patch[key] !== undefined)
+                        input[key] = patch[key];
+                }
+                const res = await client.query(UPDATE_FORM_MUTATION, { formId: idOrSlug, input });
+                return res.updateForm ? { id: res.updateForm.id } : null;
+            },
+            delete: async (idOrSlug) => {
+                const res = await client.query(DELETE_FORM_MUTATION, { formId: idOrSlug });
+                return { deleted: Boolean(res.deleteForm) };
+            },
+            listSubmissions: async (options) => {
+                const res = await client.query(FORM_SUBMISSIONS_QUERY, {
+                    ...(options?.formIdOrSlug ? { formId: options.formIdOrSlug } : {}),
+                    ...(options?.status ? { status: options.status } : {}),
+                    skip: options?.skip ?? 0,
+                    limit: options?.limit ?? 50,
+                });
+                return res.formSubmissions;
+            },
+            getSubmission: async (submissionId) => {
+                const res = await client.query(FORM_SUBMISSION_BY_ID_QUERY, { submissionId });
+                return res.formSubmission;
+            },
+            updateSubmissionStatus: async (submissionId, status) => {
+                const res = await client.query(UPDATE_FORM_SUBMISSION_STATUS_MUTATION, { submissionId, status });
+                return { ok: Boolean(res.updateFormSubmissionStatus) };
+            },
+            deleteSubmission: async (submissionId) => {
+                const res = await client.query(DELETE_FORM_SUBMISSION_MUTATION, { submissionId });
+                return { deleted: Boolean(res.deleteFormSubmission) };
+            },
+        },
+        orders: {
+            list: async (options) => {
+                const res = await client.query(ORDERS_QUERY, {
+                    workspaceId: ws,
+                    paymentStatus: options?.paymentStatus,
+                    fulfillmentStatus: options?.fulfillmentStatus,
+                    customerId: options?.customerId,
+                    search: options?.search,
+                    pipelineStageId: options?.pipelineStageId,
+                    dateFrom: options?.dateFrom,
+                    dateTo: options?.dateTo,
+                    skip: options?.skip,
+                    limit: options?.limit,
+                });
+                return {
+                    items: res.orders.items.map((o) => ({
+                        id: o.id,
+                        orderNumber: o.orderNumber ?? null,
+                        customerEmail: o.customerEmail ?? null,
+                        status: o.status ?? null,
+                        paymentStatus: o.paymentStatus ?? null,
+                        fulfillmentStatus: o.fulfillmentStatus ?? null,
+                        total: o.total ?? null,
+                        currency: o.currency ?? null,
+                        createdAt: o.createdAt ?? null,
+                    })),
+                    total: res.orders.total,
+                    hasMore: res.orders.hasMore,
+                };
+            },
+            get: async (id) => {
+                const res = await client.query(ORDER_BY_ID_QUERY, { workspaceId: ws, id });
+                const o = res.order;
+                if (!o)
+                    return null;
+                return {
+                    id: o.id,
+                    orderNumber: o.orderNumber ?? null,
+                    paymentStatus: o.paymentStatus ?? null,
+                    fulfillmentStatus: o.fulfillmentStatus ?? null,
+                    customerEmail: o.customerEmail ?? null,
+                    total: o.total ?? null,
+                    currency: o.currency ?? null,
+                    items: o.items ?? null,
+                    payments: o.payments ?? null,
+                    createdAt: o.createdAt ?? null,
+                };
+            },
+            getPipeline: async () => {
+                const res = await client.query(ORDER_PIPELINE_QUERY, { workspaceId: ws });
+                return res.orderPipeline;
+            },
+            createManual: async (customerEmail, items, customerId) => {
+                const res = await client.query(CREATE_MANUAL_ORDER_MUTATION, {
+                    input: { workspaceId: ws, customerEmail, customerId, items },
+                });
+                const o = res.createManualOrder;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            edit: async (orderId, items) => {
+                const res = await client.query(EDIT_ORDER_MUTATION, {
+                    input: { workspaceId: ws, orderId, items },
+                });
+                const o = res.editOrder;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            updateDetails: async (orderId, details) => {
+                const res = await client.query(UPDATE_ORDER_DETAILS_MUTATION, {
+                    input: { workspaceId: ws, orderId, ...details },
+                });
+                const o = res.updateOrderDetails;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            markPaid: async (orderId, payment) => {
+                const res = await client.query(MARK_ORDER_PAID_MUTATION, {
+                    input: {
+                        workspaceId: ws,
+                        orderId,
+                        amount: payment.amount,
+                        reference: payment.reference,
+                        provider: payment.provider ?? "manual",
+                    },
+                });
+                const o = res.markOrderPaid;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            recordPayment: async (orderId, payment) => {
+                const res = await client.query(RECORD_ORDER_PAYMENT_MUTATION, {
+                    input: {
+                        workspaceId: ws,
+                        orderId,
+                        amount: payment.amount,
+                        reference: payment.reference,
+                        provider: payment.provider,
+                    },
+                });
+                const o = res.recordOrderPayment;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            refund: async (orderId, reference, amount) => {
+                const res = await client.query(REFUND_ORDER_MUTATION, {
+                    input: { workspaceId: ws, orderId, reference, amount },
+                });
+                const o = res.refundOrder;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            cancel: async (orderId) => {
+                const res = await client.query(CANCEL_ORDER_MUTATION, {
+                    input: { workspaceId: ws, orderId },
+                });
+                const o = res.cancelOrder;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            transitionFulfillment: async (orderId, status, trackingNumber, trackingCarrier) => {
+                const res = await client.query(TRANSITION_ORDER_FULFILLMENT_MUTATION, {
+                    input: {
+                        workspaceId: ws,
+                        orderId,
+                        status,
+                        trackingNumber,
+                        trackingCarrier,
+                    },
+                });
+                const o = res.transitionOrderFulfillment;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            setPipelineStage: async (orderId, stageId) => {
+                const res = await client.query(SET_ORDER_PIPELINE_STAGE_MUTATION, {
+                    input: { workspaceId: ws, orderId, stageId },
+                });
+                const o = res.setOrderPipelineStage;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
+            recordInvoice: async (orderId, invoice) => {
+                const res = await client.query(RECORD_ORDER_INVOICE_MUTATION, {
+                    input: {
+                        workspaceId: ws,
+                        orderId,
+                        number: invoice.number,
+                        url: invoice.url,
+                        provider: invoice.provider,
+                    },
+                });
+                const o = res.recordOrderInvoice;
+                return { id: o.id, orderNumber: o.orderNumber ?? null };
+            },
         },
-        orders: { list: () => notBound("orders.list") },
         discounts: {
-            list: () => notBound("discounts.list"),
-            create: async (input) => {
-                const res = await client.query(CREATE_DISCOUNT_MUTATION, {
-                    workspaceId: client.workspaceId,
-                    input,
+            list: async (options) => {
+                const res = await client.query(DISCOUNTS_QUERY, {
+                    workspaceId: ws,
+                    enabled: options?.enabled,
+                    type: options?.type,
+                    search: options?.search,
+                    limit: options?.limit,
+                    offset: options?.offset,
                 });
+                return {
+                    items: res.discounts.items.map((d) => ({
+                        id: d.id,
+                        code: d.code,
+                        type: d.type,
+                        value: d.value ?? null,
+                        enabled: d.enabled,
+                        currentUses: d.currentUses ?? null,
+                    })),
+                    total: res.discounts.total,
+                    hasMore: res.discounts.hasMore,
+                };
+            },
+            create: async (input) => {
+                const res = await client.query(CREATE_DISCOUNT_MUTATION, { workspaceId: ws, input });
                 return { id: res.createDiscount.id, code: res.createDiscount.code };
             },
+            get: async (idOrSlug) => {
+                const res = await client.query(DISCOUNT_BY_ID_QUERY, { workspaceId: ws, id: idOrSlug });
+                const d = res.discount;
+                if (!d)
+                    return null;
+                return {
+                    id: d.id,
+                    code: d.code,
+                    type: d.type,
+                    value: d.value,
+                    enabled: d.enabled,
+                    currency: d.currency ?? null,
+                    minSubtotal: d.minSubtotal ?? null,
+                    maxUses: d.maxUses ?? null,
+                    maxUsesPerUser: d.maxUsesPerUser ?? null,
+                    currentUses: d.currentUses ?? null,
+                    startsAt: d.startsAt ?? null,
+                    endsAt: d.endsAt ?? null,
+                };
+            },
+            update: async (idOrSlug, patch) => {
+                const input = {};
+                for (const key of [
+                    "code",
+                    "type",
+                    "value",
+                    "currency",
+                    "minSubtotal",
+                    "maxUses",
+                    "maxUsesPerUser",
+                    "startsAt",
+                    "endsAt",
+                    "enabled",
+                ]) {
+                    if (patch[key] !== undefined)
+                        input[key] = patch[key];
+                }
+                const res = await client.query(UPDATE_DISCOUNT_MUTATION, { workspaceId: ws, id: idOrSlug, input });
+                if (!res.updateDiscount)
+                    return null;
+                return {
+                    id: res.updateDiscount.id,
+                    code: res.updateDiscount.code,
+                    enabled: res.updateDiscount.enabled,
+                };
+            },
+            setEnabled: async (idOrSlug, enabled) => {
+                const res = await client.query(SET_DISCOUNT_ENABLED_MUTATION, {
+                    workspaceId: ws,
+                    id: idOrSlug,
+                    enabled,
+                });
+                if (!res.setDiscountEnabled)
+                    return null;
+                return {
+                    id: res.setDiscountEnabled.id,
+                    code: res.setDiscountEnabled.code,
+                    enabled: res.setDiscountEnabled.enabled,
+                };
+            },
+        },
+        workspace: {
+            info: async () => {
+                const res = await client.query(CURRENT_WORKSPACE_QUERY);
+                const w = res.currentWorkspace;
+                if (!w)
+                    throw new Error("Workspace not found");
+                return {
+                    id: w.id,
+                    name: w.name,
+                    slug: w.slug,
+                    plan: w.plan ?? null,
+                    limits: w.limits ?? null,
+                };
+            },
+            siteConfig: async () => {
+                const res = await client.query(SITE_CONFIG_QUERY);
+                const c = res.siteConfig;
+                if (!c)
+                    return null;
+                return {
+                    id: c.id ?? null,
+                    defaultLanguage: c.defaultLanguage ?? null,
+                    enabledLanguages: c.enabledLanguages ?? [],
+                    siteName: c.siteName ?? null,
+                    enabledFeatures: c.enabledFeatures ?? [],
+                    header: c.header ?? null,
+                    footer: c.footer ?? null,
+                };
+            },
+        },
+        webhooks: {
+            list: async () => {
+                const res = await client.query(WEBHOOK_ENDPOINTS_QUERY, { workspaceId: ws });
+                return res.webhookEndpoints;
+            },
+            listDeliveries: async (limit) => {
+                const res = await client.query(WEBHOOK_DELIVERIES_QUERY, { workspaceId: ws, limit: limit ?? 50 });
+                return res.webhookDeliveries;
+            },
+            listEventTypes: async () => {
+                const res = await client.query(WEBHOOK_EVENT_TYPES_QUERY, { workspaceId: ws });
+                return res.webhookEventTypes;
+            },
+            create: async (input) => {
+                const res = await client.query(CREATE_WEBHOOK_ENDPOINT_MUTATION, {
+                    input: {
+                        workspaceId: ws,
+                        url: input.url,
+                        events: input.events,
+                        description: input.description,
+                    },
+                });
+                return res.createWebhookEndpoint;
+            },
+            update: async (id, patch) => {
+                const res = await client.query(UPDATE_WEBHOOK_ENDPOINT_MUTATION, { input: { workspaceId: ws, id, ...patch } });
+                return res.updateWebhookEndpoint;
+            },
+            rotateSecret: async (id) => {
+                const res = await client.query(ROTATE_WEBHOOK_SECRET_MUTATION, { workspaceId: ws, id });
+                return res.rotateWebhookSecret;
+            },
+            delete: async (id) => {
+                const res = await client.query(DELETE_WEBHOOK_ENDPOINT_MUTATION, { workspaceId: ws, id });
+                return { deleted: Boolean(res.deleteWebhookEndpoint) };
+            },
+        },
+        carts: {
+            list: async (status, skip, limit) => {
+                const res = await client.query(ADMIN_CARTS_QUERY, {
+                    workspaceId: ws,
+                    ...(status ? { status } : {}),
+                    skip: skip ?? 0,
+                    limit: limit ?? 20,
+                });
+                return res.adminCarts;
+            },
+        },
+        products: {
+            list: async (modelId, filter, limit, offset, sort) => {
+                const res = await client.query(PRODUCT_CATALOG_QUERY, { modelId, filter, limit, offset, sort });
+                return res.productCatalog;
+            },
+            bulkUpdate: async (modelId, selection, patch) => {
+                const res = await client.query(BULK_UPDATE_PRODUCT_RECORDS_MUTATION, { modelId, selection, patch });
+                return { count: res.bulkUpdateProductRecords };
+            },
+            bulkDelete: async (modelId, selection) => {
+                const res = await client.query(BULK_DELETE_PRODUCT_RECORDS_MUTATION, { modelId, selection });
+                return { count: res.bulkDeleteProductRecords };
+            },
         },
     };
 }