@kintone/mcp-server 1.0.0

package/dist/tools/kintone/app/get-form-fields.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+const inputSchema = {
+    app: z
+        .string()
+        .describe("The ID of the app to retrieve form fields from (numeric value as string)"),
+    lang: z
+        .enum(["ja", "en", "zh", "default", "user"])
+        .optional()
+        .describe("The language for field names"),
+};
+const fieldPropertySchema = z.object({
+    type: z.string().describe("The field type"),
+    code: z.string().describe("The field code"),
+    label: z.string().describe("The field name"),
+    enabled: z
+        .boolean()
+        .optional()
+        .describe("Whether the field is enabled (for STATUS and CATEGORY fields)"),
+    noLabel: z.boolean().optional().describe("Whether to hide the field name"),
+    required: z.boolean().optional().describe("Whether the field is required"),
+    unique: z.boolean().optional().describe("Whether the field must be unique"),
+    maxValue: z.string().optional().describe("Maximum value"),
+    minValue: z.string().optional().describe("Minimum value"),
+    maxLength: z.string().optional().describe("Maximum length"),
+    minLength: z.string().optional().describe("Minimum length"),
+    defaultValue: z.any().optional().describe("Default value"),
+    defaultNowValue: z
+        .boolean()
+        .optional()
+        .describe("Whether to use current date/time as default"),
+    entities: z
+        .array(z.object({
+        type: z.enum(["USER", "GROUP", "ORGANIZATION"]),
+        code: z.string(),
+    }))
+        .optional()
+        .describe("Default entities for user/group/organization selection fields"),
+    options: z
+        .record(z.object({
+        label: z.string(),
+        index: z.string(),
+    }))
+        .optional()
+        .describe("Options for selection fields"),
+    align: z
+        .enum(["HORIZONTAL", "VERTICAL"])
+        .optional()
+        .describe("Option alignment for radio/checkbox fields"),
+    expression: z.string().optional().describe("Calculation formula"),
+    hideExpression: z
+        .boolean()
+        .optional()
+        .describe("Whether to hide the formula"),
+    format: z.string().optional().describe("Display format"),
+    displayScale: z.string().optional().describe("Number of decimal places"),
+    unit: z.string().optional().describe("Unit symbol"),
+    unitPosition: z
+        .enum(["BEFORE", "AFTER"])
+        .optional()
+        .describe("Unit position"),
+    digit: z.boolean().optional().describe("Whether to use thousands separator"),
+    thumbnailSize: z.string().optional().describe("Image thumbnail size"),
+    protocol: z
+        .enum(["WEB", "CALL", "MAIL"])
+        .optional()
+        .describe("Link protocol"),
+    lookup: z
+        .object({
+        relatedApp: z.object({
+            app: z.string(),
+            code: z.string(),
+        }),
+        relatedKeyField: z.string(),
+        fieldMappings: z.array(z.object({
+            field: z.string(),
+            relatedField: z.string(),
+        })),
+        lookupPickerFields: z.array(z.string()),
+        filterCond: z.string().optional(),
+        sort: z.string().optional(),
+    })
+        .optional()
+        .describe("Lookup settings"),
+    referenceTable: z
+        .object({
+        relatedApp: z.object({
+            app: z.string(),
+            code: z.string(),
+        }),
+        condition: z.object({
+            field: z.string(),
+            relatedField: z.string(),
+        }),
+        filterCond: z.string().optional(),
+        displayFields: z.array(z.string()),
+        sort: z.string().optional(),
+        size: z.string().optional(),
+    })
+        .optional()
+        .describe("Related records settings"),
+    fields: z.record(z.any()).optional().describe("Fields in subtable"),
+    openGroup: z
+        .boolean()
+        .optional()
+        .describe("Whether the group is expanded by default"),
+});
+const outputSchema = {
+    properties: z
+        .record(fieldPropertySchema)
+        .describe("Object containing field configurations"),
+    revision: z.string().describe("App configuration revision number"),
+};
+export const getFormFields = createTool("kintone-get-form-fields", {
+    title: "Get Form Fields",
+    description: "Get form field settings from a kintone app",
+    inputSchema,
+    outputSchema,
+}, async ({ app, lang }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    const response = await client.app.getFormFields({
+        app,
+        lang,
+    });
+    const result = {
+        properties: response.properties,
+        revision: response.revision,
+    };
+    return {
+        structuredContent: result,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+});

package/dist/tools/kintone/app/get-process-management.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+const inputSchema = {
+    app: z
+        .string()
+        .describe("The ID of the app to retrieve process management settings from (numeric value as string)"),
+    lang: z
+        .enum(["ja", "en", "zh", "default", "user"])
+        .optional()
+        .describe("The language for field names"),
+};
+const entitySchema = z.object({
+    type: z.enum([
+        "USER",
+        "GROUP",
+        "ORGANIZATION",
+        "FIELD_ENTITY",
+        "CREATOR",
+        "CUSTOM_FIELD",
+    ]),
+    code: z.string().nullable(),
+});
+const entityWithSubsSchema = z.object({
+    entity: entitySchema,
+    includeSubs: z.boolean(),
+});
+const stateAssigneeSchema = z.object({
+    type: z.enum(["ONE", "ALL", "ANY"]).describe("Assignee type"),
+    entities: z.array(entityWithSubsSchema).describe("Assignee entities"),
+});
+const stateSchema = z.object({
+    name: z.string().describe("Status name"),
+    index: z.string().describe("Display order"),
+    assignee: stateAssigneeSchema
+        .optional()
+        .describe("Default assignee for the status"),
+});
+const actionSchema = z.object({
+    name: z.string().describe("Action name"),
+    from: z.string().describe("Source status name"),
+    to: z.string().describe("Destination status name"),
+    filterCond: z.string().describe("Branch condition"),
+    type: z.enum(["PRIMARY", "SECONDARY"]).describe("Action type"),
+    executableUser: z
+        .object({
+        entities: z
+            .array(entityWithSubsSchema)
+            .describe("Users who can execute the action"),
+    })
+        .optional()
+        .describe("Executable user settings"),
+});
+const outputSchema = {
+    enable: z.boolean().describe("Whether process management is enabled"),
+    states: z
+        .record(stateSchema)
+        .nullable()
+        .describe("Object containing status configurations"),
+    actions: z
+        .array(actionSchema)
+        .nullable()
+        .describe("Array containing action configurations"),
+    revision: z.string().describe("App settings revision number"),
+};
+export const getProcessManagement = createTool("kintone-get-process-management", {
+    title: "Get Process Management",
+    description: "Get process management settings from a kintone app",
+    inputSchema,
+    outputSchema,
+}, async ({ app, lang }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    const response = await client.app.getProcessManagement({
+        app,
+        lang,
+    });
+    return {
+        structuredContent: response,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(response, null, 2),
+            },
+        ],
+    };
+});

package/dist/tools/kintone/record/add-records.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+import { recordSchemaForParameterWithoutFile } from "../../../schema/record/record-for-parameter.js";
+const inputSchema = {
+    app: z
+        .string()
+        .describe("The ID of the app to add records to (numeric value as string)"),
+    records: z
+        .array(recordSchemaForParameterWithoutFile)
+        .min(1)
+        .max(100)
+        .describe("Array of records to add (min 1, max 100). Each record is an object with field codes as keys. Use kintone-get-form-fields tool first to discover available field codes and their types."),
+};
+const outputSchema = {
+    ids: z.array(z.string()).describe("Array of IDs of the created records"),
+    revisions: z
+        .array(z.string())
+        .describe("Array of revision numbers of the created records"),
+};
+export const addRecords = createTool("kintone-add-records", {
+    title: "Add Records",
+    description: "Add multiple records to a kintone app. Use kintone-get-form-fields tool first to discover available field codes and their required formats. Note: Some fields cannot be registered (LOOKUP copies, STATUS, CATEGORY, CALC, ASSIGNEE, auto-calculated fields).",
+    inputSchema,
+    outputSchema,
+}, async ({ app, records }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    const response = await client.record.addRecords({
+        app,
+        records,
+    });
+    const result = {
+        ids: response.ids,
+        revisions: response.revisions,
+    };
+    return {
+        structuredContent: result,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+});

package/dist/tools/kintone/record/delete-records.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+const inputSchema = {
+    app: z.string().describe("The ID of the app (numeric value as string)"),
+    ids: z
+        .array(z.string())
+        .describe("Array of record IDs to delete (numeric values as strings)")
+        .min(1, "At least one record ID is required")
+        .max(100, "Maximum 100 records can be deleted at once"),
+    revisions: z
+        .array(z.string())
+        .optional()
+        .describe("Array of expected revision numbers for each record (numeric values as strings). If specified, must have the same length as ids array. Deletion will fail if current revisions don't match. Specify -1 or omit to skip revision validation."),
+};
+const outputSchema = {};
+export const deleteRecords = createTool("kintone-delete-records", {
+    title: "Delete Records",
+    description: "Delete multiple records from a kintone app. Maximum 100 records can be deleted at once.",
+    inputSchema,
+    outputSchema,
+}, async ({ app, ids, revisions }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    await client.record.deleteRecords({ app, ids, revisions });
+    return {
+        structuredContent: {},
+        content: [],
+    };
+});

package/dist/tools/kintone/record/get-records.js

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+import { recordSchema } from "../../../schema/record/records.js";
+const filtersSchema = z
+    .object({
+    textContains: z
+        .array(z.object({
+        field: z.string().describe("Field code"),
+        value: z.string().describe("Text to search for"),
+    }))
+        .optional()
+        .describe("Text fields containing specified values"),
+    equals: z
+        .array(z.object({
+        field: z.string().describe("Field code"),
+        value: z.string().describe("Exact value to match"),
+    }))
+        .optional()
+        .describe("Fields equal to specified values"),
+    dateRange: z
+        .array(z.object({
+        field: z.string().describe("Field code"),
+        from: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+        to: z.string().optional().describe("End date (YYYY-MM-DD)"),
+    }))
+        .optional()
+        .describe("Date fields within specified range"),
+    numberRange: z
+        .array(z.object({
+        field: z.string().describe("Field code"),
+        min: z.number().optional().describe("Minimum value"),
+        max: z.number().optional().describe("Maximum value"),
+    }))
+        .optional()
+        .describe("Number fields within specified range"),
+    inValues: z
+        .array(z.object({
+        field: z.string().describe("Field code"),
+        values: z.array(z.string()).describe("List of values to match"),
+    }))
+        .optional()
+        .describe("Fields matching any of the specified values"),
+    notInValues: z
+        .array(z.object({
+        field: z.string().describe("Field code"),
+        values: z.array(z.string()).describe("List of values to exclude"),
+    }))
+        .optional()
+        .describe("Fields not matching any of the specified values"),
+})
+    .optional()
+    .describe("Filter conditions for records. Use kintone-get-form-fields tool to discover available field codes and types for an app");
+const orderBySchema = z
+    .array(z.object({
+    field: z.string().describe("Field code to sort by"),
+    order: z
+        .enum(["asc", "desc"])
+        .optional()
+        .describe("Sort order (default: asc)"),
+}))
+    .optional()
+    .describe("Sort order for results");
+const inputSchema = {
+    app: z
+        .string()
+        .describe("The ID of the app to retrieve records from (numeric value as string)"),
+    filters: filtersSchema,
+    fields: z
+        .array(z.string())
+        .optional()
+        .describe("Array of field codes to retrieve. If not specified, all fields are retrieved. Use kintone-get-form-fields tool to see available fields"),
+    orderBy: orderBySchema,
+    limit: z
+        .number()
+        .min(1)
+        .max(500)
+        .optional()
+        .describe("Maximum number of records to retrieve (1-500)"),
+    offset: z.number().min(0).optional().describe("Number of records to skip"),
+};
+const outputSchema = {
+    records: z
+        .array(recordSchema)
+        .describe("Array of records matching the query"),
+    totalCount: z.string().describe("Total count of records matching the query"),
+};
+function buildQueryFromFilters(filters) {
+    const conditions = [];
+    filters.textContains?.forEach((f) => {
+        conditions.push(`${f.field} like "${f.value}"`);
+    });
+    filters.equals?.forEach((f) => {
+        if (typeof f.value === "string") {
+            conditions.push(`${f.field} = "${f.value}"`);
+        }
+        else {
+            conditions.push(`${f.field} = ${f.value}`);
+        }
+    });
+    filters.dateRange?.forEach((f) => {
+        if (f.from)
+            conditions.push(`${f.field} >= "${f.from}"`);
+        if (f.to)
+            conditions.push(`${f.field} <= "${f.to}"`);
+    });
+    filters.numberRange?.forEach((f) => {
+        if (f.min !== undefined)
+            conditions.push(`${f.field} >= ${f.min}`);
+        if (f.max !== undefined)
+            conditions.push(`${f.field} <= ${f.max}`);
+    });
+    filters.inValues?.forEach((f) => {
+        const values = f.values.map((v) => `"${v}"`).join(", ");
+        conditions.push(`${f.field} in (${values})`);
+    });
+    filters.notInValues?.forEach((f) => {
+        const values = f.values.map((v) => `"${v}"`).join(", ");
+        conditions.push(`${f.field} not in (${values})`);
+    });
+    return conditions.length > 0 ? conditions.join(" and ") : undefined;
+}
+export const getRecords = createTool("kintone-get-records", {
+    title: "Get Records",
+    description: "Get multiple records from a kintone app with structured filtering. Use kintone-get-form-fields tool first to discover available fields and their types.",
+    inputSchema,
+    outputSchema,
+}, async ({ app, filters, fields, orderBy, limit, offset }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    let query = filters ? buildQueryFromFilters(filters) : undefined;
+    if (orderBy && orderBy.length > 0) {
+        const orderClauses = orderBy
+            .map((o) => `${o.field} ${o.order || "asc"}`)
+            .join(", ");
+        query = query
+            ? `${query} order by ${orderClauses}`
+            : `order by ${orderClauses}`;
+    }
+    if (limit !== undefined) {
+        query = query ? `${query} limit ${limit}` : `limit ${limit}`;
+    }
+    if (offset !== undefined) {
+        query = query ? `${query} offset ${offset}` : `offset ${offset}`;
+    }
+    const response = await client.record.getRecords({
+        app,
+        query,
+        fields,
+        totalCount: true,
+    });
+    const result = {
+        records: response.records,
+        totalCount: response.totalCount,
+    };
+    return {
+        structuredContent: result,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+});

package/dist/tools/kintone/record/update-records.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+import { recordSchemaForParameter } from "../../../schema/record/record-for-parameter.js";
+const updateRecordSchema = z.object({
+    // updateKey指定は対象外
+    id: z.string().describe("Record ID to update (numeric value as string)"),
+    record: recordSchemaForParameter.describe("Record data with field codes as keys. Use kintone-get-form-fields tool first to discover available field codes and their types."),
+    revision: z
+        .string()
+        .optional()
+        .describe("Expected revision number (numeric value as string). If specified, the update will fail if the current revision doesn't match. Specify -1 or omit to skip revision validation."),
+});
+const inputSchema = {
+    app: z
+        .string()
+        .describe("The ID of the app to update records in (numeric value as string)"),
+    records: z
+        .array(updateRecordSchema)
+        .min(1)
+        .max(100)
+        .describe("Array of records to update (min 1, max 100). Each record must have an ID to identify which record to update."),
+};
+const outputSchema = {
+    records: z
+        .array(z.object({
+        id: z.string().describe("Record ID"),
+        revision: z.string().describe("New revision number after update"),
+    }))
+        .describe("Array of updated record information"),
+};
+export const updateRecords = createTool("kintone-update-records", {
+    title: "Update Records",
+    description: "Update multiple records in a kintone app. Use kintone-get-form-fields tool first to discover available field codes and their required formats. Note: Some fields cannot be updated (LOOKUP copies, STATUS, CATEGORY, CALC, ASSIGNEE, auto-calculated fields).",
+    inputSchema,
+    outputSchema,
+}, async ({ app, records }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    const response = await client.record.updateRecords({
+        app,
+        records,
+        upsert: false, // upsertモードは対象外
+    });
+    const result = {
+        records: response.records,
+    };
+    return {
+        structuredContent: result,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+});

package/dist/tools/kintone/record/update-statuses.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { createTool } from "../../utils.js";
+import { getKintoneClient } from "../../../client.js";
+import { parseKintoneClientConfig } from "../../../config/index.js";
+const statusRecordSchema = z.object({
+    id: z.string().describe("Record ID (numeric value as string)"),
+    action: z
+        .string()
+        .describe("Action name to execute. Must be specified in the user's display language if multiple languages are configured. If multiple actions with the same name exist for the current status, an error will occur."),
+    assignee: z
+        .string()
+        .optional()
+        .describe("User login name to assign as the assignee. Required when: 1) The destination status has 'Select assignee from these users' enabled and selectable users exist, 2) Setting an assignee for the initial status when returning to it."),
+    revision: z
+        .string()
+        .optional()
+        .describe("Expected revision number (numeric value as string). If it doesn't match the actual revision, an error occurs and status is not updated. Specify -1 or omit to skip revision validation."),
+});
+const inputSchema = {
+    app: z.string().describe("The ID of the app (numeric value as string)"),
+    records: z
+        .array(statusRecordSchema)
+        .min(1)
+        .max(100)
+        .describe("Array of records to update status (min 1, max 100). Each record contains id, action, and optionally assignee and revision."),
+};
+const outputSchema = {
+    records: z
+        .array(z.object({
+        id: z.string().describe("Record ID"),
+        revision: z
+            .string()
+            .describe("New revision number after status change. The revision increases by 2 (one for action execution, one for status update)."),
+    }))
+        .describe("Array of updated record information"),
+};
+export const updateStatuses = createTool("kintone-update-statuses", {
+    title: "Update Statuses",
+    description: "Update status of multiple records in a kintone app. Requires process management feature to be enabled. Maximum 100 records can be updated at once.",
+    inputSchema,
+    outputSchema,
+}, async ({ app, records }) => {
+    const config = parseKintoneClientConfig();
+    const client = getKintoneClient(config);
+    const response = await client.record.updateRecordsStatus({
+        app,
+        records,
+    });
+    const result = {
+        records: response.records,
+    };
+    return {
+        structuredContent: result,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+});

package/dist/tools/utils.js

@@ -0,0 +1,8 @@
+// Tool creation helper function
+export function createTool(name, config, callback) {
+    return {
+        name,
+        config,
+        callback,
+    };
+}

package/dist/version.js

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not edit manually.
+export const version = "1.0.0"; // x-release-please-version