@mcp-z/mcp-outlook 1.0.0

package/dist/cjs/mcp/tools/label-delete.js

@@ -0,0 +1,497 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTool;
+    }
+});
+var _oauthmicrosoft = require("@mcp-z/oauth-microsoft");
+var _microsoftgraphclient = require("@microsoft/microsoft-graph-client");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _zod = require("zod");
+var _constantsts = require("../../constants.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+var AuthRequiredBranchSchema = _oauthmicrosoft.schemas.AuthRequiredBranchSchema;
+var BatchResultSchema = _zod.z.object({
+    totalRequested: _zod.z.number().describe('Total number of categories requested to delete'),
+    successCount: _zod.z.number().describe('Number of categories successfully deleted'),
+    failureCount: _zod.z.number().describe('Number of categories that failed to delete'),
+    results: _zod.z.array(_zod.z.object({
+        id: _zod.z.string().describe('Category ID'),
+        success: _zod.z.boolean().describe('Whether the operation succeeded'),
+        error: _zod.z.string().optional().describe('Error message if operation failed')
+    })).describe('Individual results for each category')
+});
+var inputSchema = _zod.z.object({
+    ids: _zod.z.array(_zod.z.coerce.string().trim().min(1)).min(1).max(_constantsts.MAX_BATCH_SIZE).describe('Outlook category IDs to delete')
+});
+// Success branch schema
+var successBranchSchema = BatchResultSchema.extend({
+    type: _zod.z.literal('success')
+});
+// Output schema with auth_required support
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    description: 'Delete Outlook categories permanently (irreversible). Categories organize messages by color and name.',
+    inputSchema: inputSchema,
+    outputSchema: _zod.z.object({
+        result: outputSchema
+    })
+};
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var ids, logger, invalidIds, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, id, _loop, graph, allResults, i, successCount, failureCount, result, error, message;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    ids = param.ids;
+                    logger = extra.logger;
+                    logger.info('outlook-label-delete called', {
+                        count: ids.length
+                    });
+                    // Validate IDs for Outlook-specific constraints
+                    // Note: Schema already validates non-empty, trimmed strings with min/max length
+                    // This check enforces business rule: Outlook category IDs cannot contain path separators or angle brackets
+                    invalidIds = [];
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = ids[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            id = _step.value;
+                            if (id.includes('/') || id.includes('\\') || id.includes('<') || id.includes('>')) {
+                                invalidIds.push(id);
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    if (invalidIds.length > 0) {
+                        logger.info('outlook-label-delete found invalid ids', {
+                            invalidIds: invalidIds,
+                            count: invalidIds.length
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "Found ".concat(invalidIds.length, " invalid IDs (contain invalid characters): ").concat(invalidIds.join(', ')));
+                    }
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        6,
+                        ,
+                        7
+                    ]);
+                    _loop = function(i) {
+                        var _allResults, chunk, chunkResults, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, id, error, err, processedChunkResults;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    chunk = ids.slice(i, i + _constantsts.CHUNK_SIZE);
+                                    logger.info('Processing chunk', {
+                                        chunkIndex: i / _constantsts.CHUNK_SIZE + 1,
+                                        chunkSize: chunk.length,
+                                        totalChunks: Math.ceil(ids.length / _constantsts.CHUNK_SIZE)
+                                    });
+                                    // Delete categories sequentially to avoid API lock conflicts
+                                    chunkResults = [];
+                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                    _state.label = 1;
+                                case 1:
+                                    _state.trys.push([
+                                        1,
+                                        8,
+                                        9,
+                                        10
+                                    ]);
+                                    _iterator = chunk[Symbol.iterator]();
+                                    _state.label = 2;
+                                case 2:
+                                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                        3,
+                                        7
+                                    ];
+                                    id = _step.value;
+                                    _state.label = 3;
+                                case 3:
+                                    _state.trys.push([
+                                        3,
+                                        5,
+                                        ,
+                                        6
+                                    ]);
+                                    return [
+                                        4,
+                                        graph.api("/me/outlook/masterCategories/".concat(encodeURIComponent(id))).delete()
+                                    ];
+                                case 4:
+                                    _state.sent();
+                                    chunkResults.push({
+                                        status: 'fulfilled',
+                                        value: {
+                                            id: id,
+                                            success: true
+                                        }
+                                    });
+                                    return [
+                                        3,
+                                        6
+                                    ];
+                                case 5:
+                                    error = _state.sent();
+                                    chunkResults.push({
+                                        status: 'rejected',
+                                        reason: error
+                                    });
+                                    return [
+                                        3,
+                                        6
+                                    ];
+                                case 6:
+                                    _iteratorNormalCompletion = true;
+                                    return [
+                                        3,
+                                        2
+                                    ];
+                                case 7:
+                                    return [
+                                        3,
+                                        10
+                                    ];
+                                case 8:
+                                    err = _state.sent();
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                    return [
+                                        3,
+                                        10
+                                    ];
+                                case 9:
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                    return [
+                                        7
+                                    ];
+                                case 10:
+                                    // Process chunk results
+                                    processedChunkResults = chunkResults.map(function(result, chunkIndex) {
+                                        var id = chunk[chunkIndex];
+                                        if (!id) {
+                                            throw new Error("Chunk index ".concat(chunkIndex, " is out of bounds for chunk of size ").concat(chunk.length));
+                                        }
+                                        if (result.status === 'fulfilled') {
+                                            return {
+                                                id: id,
+                                                success: true
+                                            };
+                                        }
+                                        // Extract error message more robustly
+                                        var errorMessage = 'Unknown error';
+                                        if (result.reason) {
+                                            if (typeof result.reason === 'string') {
+                                                errorMessage = result.reason;
+                                            } else if (_instanceof(result.reason, Error)) {
+                                                errorMessage = result.reason.message;
+                                            } else if (result.reason && _type_of(result.reason) === 'object' && 'message' in result.reason) {
+                                                errorMessage = String(result.reason.message);
+                                            } else if (result.reason && _type_of(result.reason) === 'object' && 'error' in result.reason) {
+                                                errorMessage = String(result.reason.error);
+                                            } else {
+                                                errorMessage = String(result.reason);
+                                            }
+                                        }
+                                        return {
+                                            id: id,
+                                            success: false,
+                                            error: errorMessage
+                                        };
+                                    });
+                                    (_allResults = allResults).push.apply(_allResults, _to_consumable_array(processedChunkResults));
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    };
+                    graph = _microsoftgraphclient.Client.initWithMiddleware({
+                        authProvider: extra.authContext.auth
+                    });
+                    // Process deletions in chunks to prevent memory exhaustion
+                    allResults = [];
+                    i = 0;
+                    _state.label = 2;
+                case 2:
+                    if (!(i < ids.length)) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        5,
+                        _ts_values(_loop(i))
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    i += _constantsts.CHUNK_SIZE;
+                    return [
+                        3,
+                        2
+                    ];
+                case 5:
+                    successCount = allResults.filter(function(r) {
+                        return r.success;
+                    }).length;
+                    failureCount = allResults.filter(function(r) {
+                        return !r.success;
+                    }).length;
+                    result = {
+                        type: 'success',
+                        totalRequested: ids.length,
+                        successCount: successCount,
+                        failureCount: failureCount,
+                        results: allResults
+                    };
+                    logger.info('outlook-label-delete completed', {
+                        totalRequested: ids.length,
+                        successCount: successCount,
+                        failureCount: failureCount,
+                        chunksProcessed: Math.ceil(ids.length / _constantsts.CHUNK_SIZE)
+                    });
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 6:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    logger.error('outlook-label-delete error', {
+                        error: message
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error deleting categories: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 7:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'label-delete',
+        config: config,
+        handler: handler
+    };
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/mcp/tools/label-delete.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-outlook/src/mcp/tools/label-delete.ts"],"sourcesContent":["import type { EnrichedExtra } from '@mcp-z/oauth-microsoft';\nimport { schemas } from '@mcp-z/oauth-microsoft';\n\nconst { AuthRequiredBranchSchema } = schemas;\n\nimport type { ToolModule } from '@mcp-z/server';\nimport { Client } from '@microsoft/microsoft-graph-client';\nimport { type CallToolResult, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';\nimport { z } from 'zod';\nimport { CHUNK_SIZE, MAX_BATCH_SIZE } from '../../constants.ts';\n\nconst BatchResultSchema = z.object({\n  totalRequested: z.number().describe('Total number of categories requested to delete'),\n  successCount: z.number().describe('Number of categories successfully deleted'),\n  failureCount: z.number().describe('Number of categories that failed to delete'),\n  results: z\n    .array(\n      z.object({\n        id: z.string().describe('Category ID'),\n        success: z.boolean().describe('Whether the operation succeeded'),\n        error: z.string().optional().describe('Error message if operation failed'),\n      })\n    )\n    .describe('Individual results for each category'),\n});\n\nconst inputSchema = z.object({\n  ids: z.array(z.coerce.string().trim().min(1)).min(1).max(MAX_BATCH_SIZE).describe('Outlook category IDs to delete'),\n});\n\n// Success branch schema\nconst successBranchSchema = BatchResultSchema.extend({\n  type: z.literal('success'),\n});\n\n// Output schema with auth_required support\nconst outputSchema = z.discriminatedUnion('type', [successBranchSchema, AuthRequiredBranchSchema]);\n\nconst config = {\n  description: 'Delete Outlook categories permanently (irreversible). Categories organize messages by color and name.',\n  inputSchema: inputSchema,\n  outputSchema: z.object({\n    result: outputSchema,\n  }),\n} as const;\n\nexport type Input = z.infer<typeof inputSchema>;\nexport type Output = z.infer<typeof outputSchema>;\n\nasync function handler({ ids }: Input, extra: EnrichedExtra): Promise<CallToolResult> {\n  const logger = extra.logger;\n  logger.info('outlook-label-delete called', { count: ids.length });\n\n  // Validate IDs for Outlook-specific constraints\n  // Note: Schema already validates non-empty, trimmed strings with min/max length\n  // This check enforces business rule: Outlook category IDs cannot contain path separators or angle brackets\n  const invalidIds: string[] = [];\n  for (const id of ids) {\n    if (id.includes('/') || id.includes('\\\\') || id.includes('<') || id.includes('>')) {\n      invalidIds.push(id);\n    }\n  }\n\n  if (invalidIds.length > 0) {\n    logger.info('outlook-label-delete found invalid ids', { invalidIds, count: invalidIds.length });\n    throw new McpError(ErrorCode.InvalidParams, `Found ${invalidIds.length} invalid IDs (contain invalid characters): ${invalidIds.join(', ')}`);\n  }\n\n  try {\n    const graph = Client.initWithMiddleware({ authProvider: extra.authContext.auth });\n    // Process deletions in chunks to prevent memory exhaustion\n    const allResults: Array<{ id: string; success: boolean; error?: string }> = [];\n\n    for (let i = 0; i < ids.length; i += CHUNK_SIZE) {\n      const chunk = ids.slice(i, i + CHUNK_SIZE);\n      logger.info('Processing chunk', { chunkIndex: i / CHUNK_SIZE + 1, chunkSize: chunk.length, totalChunks: Math.ceil(ids.length / CHUNK_SIZE) });\n\n      // Delete categories sequentially to avoid API lock conflicts\n      const chunkResults: Array<{ status: string; value?: unknown; reason?: unknown }> = [];\n      for (const id of chunk) {\n        try {\n          await graph.api(`/me/outlook/masterCategories/${encodeURIComponent(id)}`).delete();\n          chunkResults.push({ status: 'fulfilled', value: { id, success: true } });\n        } catch (error) {\n          chunkResults.push({ status: 'rejected', reason: error });\n        }\n      }\n\n      // Process chunk results\n      const processedChunkResults = chunkResults.map((result, chunkIndex) => {\n        const id = chunk[chunkIndex];\n        if (!id) {\n          throw new Error(`Chunk index ${chunkIndex} is out of bounds for chunk of size ${chunk.length}`);\n        }\n        if (result.status === 'fulfilled') {\n          return { id, success: true };\n        }\n\n        // Extract error message more robustly\n        let errorMessage = 'Unknown error';\n        if (result.reason) {\n          if (typeof result.reason === 'string') {\n            errorMessage = result.reason;\n          } else if (result.reason instanceof Error) {\n            errorMessage = result.reason.message;\n          } else if (result.reason && typeof result.reason === 'object' && 'message' in result.reason) {\n            errorMessage = String(result.reason.message);\n          } else if (result.reason && typeof result.reason === 'object' && 'error' in result.reason) {\n            errorMessage = String(result.reason.error);\n          } else {\n            errorMessage = String(result.reason);\n          }\n        }\n\n        return { id, success: false, error: errorMessage };\n      });\n\n      allResults.push(...processedChunkResults);\n    }\n\n    const successCount = allResults.filter((r) => r.success).length;\n    const failureCount = allResults.filter((r) => !r.success).length;\n\n    const result: Output = {\n      type: 'success' as const,\n      totalRequested: ids.length,\n      successCount,\n      failureCount,\n      results: allResults,\n    };\n\n    logger.info('outlook-label-delete completed', {\n      totalRequested: ids.length,\n      successCount,\n      failureCount,\n      chunksProcessed: Math.ceil(ids.length / CHUNK_SIZE),\n    });\n\n    return {\n      content: [\n        {\n          type: 'text' as const,\n          text: JSON.stringify(result),\n        },\n      ],\n      structuredContent: { result },\n    };\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    logger.error('outlook-label-delete error', { error: message });\n\n    throw new McpError(ErrorCode.InternalError, `Error deleting categories: ${message}`, {\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n  }\n}\n\nexport default function createTool() {\n  return {\n    name: 'label-delete',\n    config,\n    handler,\n  } satisfies ToolModule;\n}\n"],"names":["createTool","AuthRequiredBranchSchema","schemas","BatchResultSchema","z","object","totalRequested","number","describe","successCount","failureCount","results","array","id","string","success","boolean","error","optional","inputSchema","ids","coerce","trim","min","max","MAX_BATCH_SIZE","successBranchSchema","extend","type","literal","outputSchema","discriminatedUnion","config","description","result","handler","extra","logger","invalidIds","graph","allResults","i","message","info","count","length","includes","push","McpError","ErrorCode","InvalidParams","join","chunk","chunkResults","processedChunkResults","slice","CHUNK_SIZE","chunkIndex","chunkSize","totalChunks","Math","ceil","api","encodeURIComponent","delete","status","value","reason","map","Error","errorMessage","String","Client","initWithMiddleware","authProvider","authContext","auth","filter","r","chunksProcessed","content","text","JSON","stringify","structuredContent","InternalError","stack","undefined","name"],"mappings":";;;;+BA6JA;;;eAAwBA;;;8BA5JA;oCAKD;qBACkC;mBACvC;2BACyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAN3C,IAAM,AAAEC,2BAA6BC,uBAAO,CAApCD;AAQR,IAAME,oBAAoBC,MAAC,CAACC,MAAM,CAAC;IACjCC,gBAAgBF,MAAC,CAACG,MAAM,GAAGC,QAAQ,CAAC;IACpCC,cAAcL,MAAC,CAACG,MAAM,GAAGC,QAAQ,CAAC;IAClCE,cAAcN,MAAC,CAACG,MAAM,GAAGC,QAAQ,CAAC;IAClCG,SAASP,MAAC,CACPQ,KAAK,CACJR,MAAC,CAACC,MAAM,CAAC;QACPQ,IAAIT,MAAC,CAACU,MAAM,GAAGN,QAAQ,CAAC;QACxBO,SAASX,MAAC,CAACY,OAAO,GAAGR,QAAQ,CAAC;QAC9BS,OAAOb,MAAC,CAACU,MAAM,GAAGI,QAAQ,GAAGV,QAAQ,CAAC;IACxC,IAEDA,QAAQ,CAAC;AACd;AAEA,IAAMW,cAAcf,MAAC,CAACC,MAAM,CAAC;IAC3Be,KAAKhB,MAAC,CAACQ,KAAK,CAACR,MAAC,CAACiB,MAAM,CAACP,MAAM,GAAGQ,IAAI,GAAGC,GAAG,CAAC,IAAIA,GAAG,CAAC,GAAGC,GAAG,CAACC,2BAAc,EAAEjB,QAAQ,CAAC;AACpF;AAEA,wBAAwB;AACxB,IAAMkB,sBAAsBvB,kBAAkBwB,MAAM,CAAC;IACnDC,MAAMxB,MAAC,CAACyB,OAAO,CAAC;AAClB;AAEA,2CAA2C;AAC3C,IAAMC,eAAe1B,MAAC,CAAC2B,kBAAkB,CAAC,QAAQ;IAACL;IAAqBzB;CAAyB;AAEjG,IAAM+B,SAAS;IACbC,aAAa;IACbd,aAAaA;IACbW,cAAc1B,MAAC,CAACC,MAAM,CAAC;QACrB6B,QAAQJ;IACV;AACF;AAKA,SAAeK;wCAAQ,KAAc,EAAEC,KAAoB;YAAlChB,KACjBiB,QAMAC,YACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMzB,WAYH0B,OAEAC,YAEGC,GA+CHhC,cACAC,cAEAwB,QAwBCjB,OACDyB;;;;oBAnGetB,MAAF,MAAEA;oBACjBiB,SAASD,MAAMC,MAAM;oBAC3BA,OAAOM,IAAI,CAAC,+BAA+B;wBAAEC,OAAOxB,IAAIyB,MAAM;oBAAC;oBAE/D,gDAAgD;oBAChD,gFAAgF;oBAChF,2GAA2G;oBACrGP;oBACD,kCAAA,2BAAA;;wBAAL,IAAK,YAAYlB,0BAAZ,6BAAA,QAAA,yBAAA,iCAAiB;4BAAXP,KAAN;4BACH,IAAIA,GAAGiC,QAAQ,CAAC,QAAQjC,GAAGiC,QAAQ,CAAC,SAASjC,GAAGiC,QAAQ,CAAC,QAAQjC,GAAGiC,QAAQ,CAAC,MAAM;gCACjFR,WAAWS,IAAI,CAAClC;4BAClB;wBACF;;wBAJK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAML,IAAIyB,WAAWO,MAAM,GAAG,GAAG;wBACzBR,OAAOM,IAAI,CAAC,0CAA0C;4BAAEL,YAAAA;4BAAYM,OAAON,WAAWO,MAAM;wBAAC;wBAC7F,MAAM,IAAIG,eAAQ,CAACC,gBAAS,CAACC,aAAa,EAAE,AAAC,SAAuEZ,OAA/DA,WAAWO,MAAM,EAAC,+CAAmE,OAAtBP,WAAWa,IAAI,CAAC;oBACtI;;;;;;;;;;4BAmDIX,aA3CMY,OAIAC,cACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMxC,IAIAI,YAMLqC;;;;oCAfAF,QAAQhC,IAAImC,KAAK,CAACd,GAAGA,IAAIe,uBAAU;oCACzCnB,OAAOM,IAAI,CAAC,oBAAoB;wCAAEc,YAAYhB,IAAIe,uBAAU,GAAG;wCAAGE,WAAWN,MAAMP,MAAM;wCAAEc,aAAaC,KAAKC,IAAI,CAACzC,IAAIyB,MAAM,GAAGW,uBAAU;oCAAE;oCAE3I,6DAA6D;oCACvDH;oCACD,kCAAA,2BAAA;;;;;;;;;oCAAA,YAAYD;;;2CAAZ,6BAAA,QAAA;;;;oCAAMvC,KAAN;;;;;;;;;oCAED;;wCAAM0B,MAAMuB,GAAG,CAAC,AAAC,gCAAsD,OAAvBC,mBAAmBlD,MAAOmD,MAAM;;;oCAAhF;oCACAX,aAAaN,IAAI,CAAC;wCAAEkB,QAAQ;wCAAaC,OAAO;4CAAErD,IAAAA;4CAAIE,SAAS;wCAAK;oCAAE;;;;;;oCAC/DE;oCACPoC,aAAaN,IAAI,CAAC;wCAAEkB,QAAQ;wCAAYE,QAAQlD;oCAAM;;;;;;oCALrD;;;;;;;;;;;;oCAAA;oCAAA;;;;;;;6CAAA,6BAAA;4CAAA;;;4CAAA;kDAAA;;;;;;;oCASL,wBAAwB;oCAClBqC,wBAAwBD,aAAae,GAAG,CAAC,SAAClC,QAAQuB;wCACtD,IAAM5C,KAAKuC,KAAK,CAACK,WAAW;wCAC5B,IAAI,CAAC5C,IAAI;4CACP,MAAM,IAAIwD,MAAM,AAAC,eAA+DjB,OAAjDK,YAAW,wCAAmD,OAAbL,MAAMP,MAAM;wCAC9F;wCACA,IAAIX,OAAO+B,MAAM,KAAK,aAAa;4CACjC,OAAO;gDAAEpD,IAAAA;gDAAIE,SAAS;4CAAK;wCAC7B;wCAEA,sCAAsC;wCACtC,IAAIuD,eAAe;wCACnB,IAAIpC,OAAOiC,MAAM,EAAE;4CACjB,IAAI,OAAOjC,OAAOiC,MAAM,KAAK,UAAU;gDACrCG,eAAepC,OAAOiC,MAAM;4CAC9B,OAAO,IAAIjC,AAAa,YAAbA,OAAOiC,MAAM,EAAYE,QAAO;gDACzCC,eAAepC,OAAOiC,MAAM,CAACzB,OAAO;4CACtC,OAAO,IAAIR,OAAOiC,MAAM,IAAI,SAAOjC,OAAOiC,MAAM,MAAK,YAAY,aAAajC,OAAOiC,MAAM,EAAE;gDAC3FG,eAAeC,OAAOrC,OAAOiC,MAAM,CAACzB,OAAO;4CAC7C,OAAO,IAAIR,OAAOiC,MAAM,IAAI,SAAOjC,OAAOiC,MAAM,MAAK,YAAY,WAAWjC,OAAOiC,MAAM,EAAE;gDACzFG,eAAeC,OAAOrC,OAAOiC,MAAM,CAAClD,KAAK;4CAC3C,OAAO;gDACLqD,eAAeC,OAAOrC,OAAOiC,MAAM;4CACrC;wCACF;wCAEA,OAAO;4CAAEtD,IAAAA;4CAAIE,SAAS;4CAAOE,OAAOqD;wCAAa;oCACnD;oCAEA9B,CAAAA,cAAAA,YAAWO,IAAI,OAAfP,aAAgB,qBAAGc;;;;;;oBACrB;oBAjDMf,QAAQiC,4BAAM,CAACC,kBAAkB,CAAC;wBAAEC,cAActC,MAAMuC,WAAW,CAACC,IAAI;oBAAC;oBAC/E,2DAA2D;oBACrDpC;oBAEGC,IAAI;;;yBAAGA,CAAAA,IAAIrB,IAAIyB,MAAM,AAAD;;;;;;;;;;;;oBAAGJ,KAAKe,uBAAU;;;;;;oBA+CzC/C,eAAe+B,WAAWqC,MAAM,CAAC,SAACC;+BAAMA,EAAE/D,OAAO;uBAAE8B,MAAM;oBACzDnC,eAAe8B,WAAWqC,MAAM,CAAC,SAACC;+BAAM,CAACA,EAAE/D,OAAO;uBAAE8B,MAAM;oBAE1DX,SAAiB;wBACrBN,MAAM;wBACNtB,gBAAgBc,IAAIyB,MAAM;wBAC1BpC,cAAAA;wBACAC,cAAAA;wBACAC,SAAS6B;oBACX;oBAEAH,OAAOM,IAAI,CAAC,kCAAkC;wBAC5CrC,gBAAgBc,IAAIyB,MAAM;wBAC1BpC,cAAAA;wBACAC,cAAAA;wBACAqE,iBAAiBnB,KAAKC,IAAI,CAACzC,IAAIyB,MAAM,GAAGW,uBAAU;oBACpD;oBAEA;;wBAAO;4BACLwB,OAAO;gCACL;oCACEpD,MAAM;oCACNqD,MAAMC,KAAKC,SAAS,CAACjD;gCACvB;;4BAEFkD,mBAAmB;gCAAElD,QAAAA;4BAAO;wBAC9B;;;oBACOjB;oBACDyB,UAAUzB,AAAK,YAALA,OAAiBoD,SAAQpD,MAAMyB,OAAO,GAAG6B,OAAOtD;oBAChEoB,OAAOpB,KAAK,CAAC,8BAA8B;wBAAEA,OAAOyB;oBAAQ;oBAE5D,MAAM,IAAIM,eAAQ,CAACC,gBAAS,CAACoC,aAAa,EAAE,AAAC,8BAAqC,OAAR3C,UAAW;wBACnF4C,OAAOrE,AAAK,YAALA,OAAiBoD,SAAQpD,MAAMqE,KAAK,GAAGC;oBAChD;;;;;;;IAEJ;;AAEe,SAASvF;IACtB,OAAO;QACLwF,MAAM;QACNxD,QAAAA;QACAG,SAAAA;IACF;AACF"}

package/dist/cjs/mcp/tools/labels-list.d.cts

@@ -0,0 +1,96 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-microsoft';
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        color: z.ZodEnum<{
+            preset0: "preset0";
+            preset1: "preset1";
+            preset2: "preset2";
+            preset3: "preset3";
+            preset4: "preset4";
+            preset5: "preset5";
+            preset6: "preset6";
+            preset7: "preset7";
+            preset8: "preset8";
+            preset9: "preset9";
+            preset10: "preset10";
+            preset11: "preset11";
+            preset12: "preset12";
+            preset13: "preset13";
+            preset14: "preset14";
+            preset15: "preset15";
+            preset16: "preset16";
+            preset17: "preset17";
+            preset18: "preset18";
+            preset19: "preset19";
+            preset20: "preset20";
+            preset21: "preset21";
+            preset22: "preset22";
+            preset23: "preset23";
+            preset24: "preset24";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler(_: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "List Outlook categories for label: query syntax. Case-sensitive.";
+        readonly inputSchema: z.ZodObject<{}, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    displayName: z.ZodString;
+                    color: z.ZodEnum<{
+                        preset0: "preset0";
+                        preset1: "preset1";
+                        preset2: "preset2";
+                        preset3: "preset3";
+                        preset4: "preset4";
+                        preset5: "preset5";
+                        preset6: "preset6";
+                        preset7: "preset7";
+                        preset8: "preset8";
+                        preset9: "preset9";
+                        preset10: "preset10";
+                        preset11: "preset11";
+                        preset12: "preset12";
+                        preset13: "preset13";
+                        preset14: "preset14";
+                        preset15: "preset15";
+                        preset16: "preset16";
+                        preset17: "preset17";
+                        preset18: "preset18";
+                        preset19: "preset19";
+                        preset20: "preset20";
+                        preset21: "preset21";
+                        preset22: "preset22";
+                        preset23: "preset23";
+                        preset24: "preset24";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};