@sellable/mcp 0.1.294 → 0.1.295

package/dist/tools/column-reorder.js

@@ -0,0 +1,65 @@
+import { getApi } from "../api.js";
+export const columnReorderToolDefinitions = [
+    {
+        name: "reorder_columns",
+        description: "Reorder workflow-table columns using exact backend order semantics. Supply every column ID in desired order.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: { type: "string" },
+                orderedColumnIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    minItems: 1,
+                },
+            },
+            required: ["tableId", "orderedColumnIds"],
+            additionalProperties: false,
+        },
+    },
+];
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export async function handleReorderColumns(input) {
+    if (!isRecord(input)) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "Arguments must be an object.",
+        };
+    }
+    const { tableId, orderedColumnIds } = input;
+    if (typeof tableId !== "string" || tableId.trim() === "") {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "tableId is required.",
+        };
+    }
+    if (!Array.isArray(orderedColumnIds) || orderedColumnIds.length === 0) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "orderedColumnIds must be a non-empty array.",
+        };
+    }
+    if (orderedColumnIds.some((id) => typeof id !== "string" || id.trim() === "")) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "orderedColumnIds must contain non-empty strings.",
+        };
+    }
+    const uniqueIds = new Set(orderedColumnIds);
+    if (uniqueIds.size !== orderedColumnIds.length) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "orderedColumnIds must not contain duplicates.",
+        };
+    }
+    return getApi().post(`/api/v3/workflow-tables/${tableId}/columns/reorder`, {
+        orderedColumnIds,
+    });
+}

package/dist/tools/column-schema.d.ts

@@ -0,0 +1,101 @@
+import { type ColumnSchemaRow } from "../generated/column-schema-manifest.js";
+export declare const columnSchemaToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            includeHidden: {
+                type: string;
+                description: string;
+            };
+            includeDeprecated: {
+                type: string;
+                description: string;
+            };
+            optionId?: undefined;
+            columnType?: undefined;
+        };
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            optionId: {
+                type: string;
+                description: string;
+            };
+            columnType: {
+                type: string;
+                description: string;
+            };
+            includeHidden?: undefined;
+            includeDeprecated?: undefined;
+        };
+        additionalProperties: boolean;
+    };
+})[];
+export declare function handleListColumnTypes(input?: unknown): {
+    ok: boolean;
+    error: string;
+    message: string;
+    counts?: undefined;
+    createableTypes?: undefined;
+    rows?: undefined;
+} | {
+    ok: boolean;
+    counts: {
+        visible: number;
+        hiddenActive: number;
+        deprecatedLoadOnly: number;
+        returned: number;
+    };
+    createableTypes: string[];
+    rows: ColumnSchemaRow[];
+    error?: undefined;
+    message?: undefined;
+};
+export declare function handleGetColumnSchema(input: unknown): {
+    ok: boolean;
+    error: string;
+    message: string;
+    optionId?: undefined;
+    row?: undefined;
+    columnType?: undefined;
+    optionIds?: undefined;
+} | {
+    ok: boolean;
+    error: string;
+    optionId: string;
+    message?: undefined;
+    row?: undefined;
+    columnType?: undefined;
+    optionIds?: undefined;
+} | {
+    ok: boolean;
+    row: ColumnSchemaRow;
+    error?: undefined;
+    message?: undefined;
+    optionId?: undefined;
+    columnType?: undefined;
+    optionIds?: undefined;
+} | {
+    ok: boolean;
+    error: string;
+    columnType: string | undefined;
+    message?: undefined;
+    optionId?: undefined;
+    row?: undefined;
+    optionIds?: undefined;
+} | {
+    ok: boolean;
+    error: string;
+    columnType: string | undefined;
+    optionIds: string[];
+    message?: undefined;
+    optionId?: undefined;
+    row?: undefined;
+};

package/dist/tools/column-schema.js

@@ -0,0 +1,137 @@
+import { columnSchemaManifest, } from "../generated/column-schema-manifest.js";
+export const columnSchemaToolDefinitions = [
+    {
+        name: "list_column_types",
+        description: "List workflow-table column options MCP can discover, including createable UI options by default and hidden/deprecated rows when requested.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                includeHidden: {
+                    type: "boolean",
+                    description: "Include hidden active non-createable column types.",
+                },
+                includeDeprecated: {
+                    type: "boolean",
+                    description: "Include deprecated/load-only non-createable aliases.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "get_column_schema",
+        description: "Get MCP discovery metadata for one workflow-table column option. Prefer optionId when a columnType has multiple visible presets.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                optionId: {
+                    type: "string",
+                    description: "Specific option id, such as http_request.generic or http_request.enrich_prospect.",
+                },
+                columnType: {
+                    type: "string",
+                    description: "Column type id. Ambiguous shared types return matching optionIds.",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function rowIsIncluded(row, input) {
+    if (row.kind === "visible")
+        return true;
+    if (row.kind === "hidden_active")
+        return input.includeHidden === true;
+    if (row.kind === "deprecated_load_only") {
+        return input.includeDeprecated === true;
+    }
+    return false;
+}
+export function handleListColumnTypes(input = {}) {
+    if (!isRecord(input)) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "Arguments must be an object.",
+        };
+    }
+    if ((input.includeHidden !== undefined &&
+        typeof input.includeHidden !== "boolean") ||
+        (input.includeDeprecated !== undefined &&
+            typeof input.includeDeprecated !== "boolean")) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "includeHidden and includeDeprecated must be booleans.",
+        };
+    }
+    const listInput = input;
+    const rows = columnSchemaManifest.rows.filter((row) => rowIsIncluded(row, listInput));
+    return {
+        ok: true,
+        counts: {
+            returned: rows.length,
+            ...columnSchemaManifest.counts,
+        },
+        createableTypes: columnSchemaManifest.createableTypes,
+        rows,
+    };
+}
+export function handleGetColumnSchema(input) {
+    if (!isRecord(input)) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "Arguments must be an object.",
+        };
+    }
+    const { optionId, columnType } = input;
+    const hasOptionId = typeof optionId === "string" && optionId.trim() !== "";
+    const hasColumnType = typeof columnType === "string" && columnType.trim() !== "";
+    if ((optionId !== undefined && typeof optionId !== "string") ||
+        (columnType !== undefined && typeof columnType !== "string")) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "optionId and columnType must be strings when supplied.",
+        };
+    }
+    if (hasOptionId === hasColumnType) {
+        return {
+            ok: false,
+            error: "invalid_selector",
+            message: "Supply exactly one non-empty optionId or columnType.",
+        };
+    }
+    if (hasOptionId) {
+        const row = columnSchemaManifest.rows.find((candidate) => candidate.optionId === optionId);
+        if (!row) {
+            return {
+                ok: false,
+                error: "not_found",
+                optionId,
+            };
+        }
+        return { ok: true, row };
+    }
+    const matches = columnSchemaManifest.rows.filter((candidate) => candidate.columnType === columnType);
+    if (matches.length === 0) {
+        return {
+            ok: false,
+            error: "not_found",
+            columnType,
+        };
+    }
+    if (matches.length > 1) {
+        return {
+            ok: false,
+            error: "ambiguous_column_type",
+            columnType,
+            optionIds: matches.map((row) => row.optionId),
+        };
+    }
+    return { ok: true, row: matches[0] };
+}

package/dist/tools/column-update.d.ts

@@ -0,0 +1,36 @@
+export type UpdateColumnInput = {
+    tableId: string;
+    columnId: string;
+    name?: string;
+    config?: Record<string, unknown>;
+    runCells?: boolean;
+};
+export declare const columnUpdateToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+            };
+            columnId: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            config: {
+                type: string;
+                description: string;
+            };
+            runCells: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function handleUpdateColumn(input: unknown): Promise<unknown>;

package/dist/tools/column-update.js

@@ -0,0 +1,88 @@
+import { getApi } from "../api.js";
+export const columnUpdateToolDefinitions = [
+    {
+        name: "update_column",
+        description: "Update a workflow-table column name or full replacement config. Use runCells:true to reprocess eligible cells after a config update.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: { type: "string" },
+                columnId: { type: "string" },
+                name: { type: "string" },
+                config: {
+                    type: "object",
+                    description: "Full replacement column config; use get_column_schema first for the expected shape.",
+                },
+                runCells: {
+                    type: "boolean",
+                    description: "When true, reprocess/queue eligible cells.",
+                },
+            },
+            required: ["tableId", "columnId"],
+            additionalProperties: false,
+        },
+    },
+];
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export async function handleUpdateColumn(input) {
+    if (!isRecord(input)) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "Arguments must be an object.",
+        };
+    }
+    const { tableId, columnId, name, config, runCells } = input;
+    if (typeof tableId !== "string" || tableId.trim() === "") {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "tableId is required.",
+        };
+    }
+    if (typeof columnId !== "string" || columnId.trim() === "") {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "columnId is required.",
+        };
+    }
+    if (name !== undefined && typeof name !== "string") {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "name must be a string.",
+        };
+    }
+    if (config !== undefined && !isRecord(config)) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "config must be an object.",
+        };
+    }
+    if (runCells !== undefined && typeof runCells !== "boolean") {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "runCells must be a boolean.",
+        };
+    }
+    if (name === undefined && config === undefined && runCells === undefined) {
+        return {
+            ok: false,
+            error: "invalid_arguments",
+            message: "At least one of name, config, or runCells is required.",
+        };
+    }
+    const body = {};
+    if (name !== undefined)
+        body.name = name;
+    if (config !== undefined)
+        body.config = config;
+    if (runCells !== undefined)
+        body.runCells = runCells;
+    return getApi().patch(`/api/v3/workflow-tables/${tableId}/columns/${columnId}`, body);
+}