@jskit-ai/connectors-catalog 0.1.1

package/src/server/microsoft-excel.js

@@ -0,0 +1,67 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { microsoftExcelDefinition } from "../shared/microsoft.js";
+import { graphRead, microsoftProvider, driveItemId, pageSize } from "./microsoft.js";
+
+const sessionId = { type: "string", minLength: 1, maxLength: 1024,
+  validator: (value) => /^[^\r\n]+$/u.test(value) || "Use the returned workbook session ID." };
+const rangeFields = {
+  itemId: driveItemId,
+  worksheetId: { type: "string", required: true, minLength: 1, maxLength: 256,
+    validator: (value) => /^[^/\\?#'\r\n]+$/u.test(value) || "Use a worksheet ID or name." },
+  address: { type: "string", required: true, maxLength: 30,
+    validator: (value) => /^[A-Z]{1,3}[1-9][0-9]{0,6}(?::[A-Z]{1,3}[1-9][0-9]{0,6})?$/u.test(value) || "Enter a bounded A1 range, such as A1:B2." },
+  sessionId
+};
+const rangeResult = (value) => typeof value?.address === "string" && Array.isArray(value.values);
+function rangeOperation(write) {
+  const schema = createSchema({ ...rangeFields, ...(write ? {
+    values: { type: "array" }, formulas: { type: "array" }
+  } : {}) });
+  return { scopes: ["Files.ReadWrite"], validateResult: rangeResult, request(input) {
+    const params = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const cells = params.address.split(":").map((cell) => {
+      const [, letters, row] = /^([A-Z]+)([0-9]+)$/u.exec(cell);
+      return { column: [...letters].reduce((n, c) => n * 26 + c.charCodeAt(0) - 64, 0), row: Number(row) };
+    });
+    const first = cells[0], last = cells[1] || first;
+    const rows = last.row - first.row + 1, columns = last.column - first.column + 1;
+    const bounded = rows > 0 && columns > 0 && rows * columns <= 10000 && last.row <= 1048576 && last.column <= 16384;
+    const matrix = (value) => Array.isArray(value) && value.length === rows && value.every((row) =>
+      Array.isArray(row) && row.length === columns && row.every((cell) => cell === null ||
+        typeof cell === "string" || typeof cell === "boolean" || (typeof cell === "number" && Number.isFinite(cell))));
+    const validation = createSchema({ valid: { type: "boolean", required: true,
+      validator: (value) => value || "Use at most 10,000 valid cells and exactly matching values or formulas, not both." } });
+    validateSchemaPayload({ schema: validation, mode: "replace" }, { valid: bounded && (!write ||
+      ((params.values !== undefined) !== (params.formulas !== undefined)) && matrix(params.values ?? params.formulas)) }, { statusCode: 422 });
+    return { method: write ? "PATCH" : "GET",
+      url: `https://graph.microsoft.com/v1.0/me/drive/items/${encodeURIComponent(params.itemId)}/workbook/worksheets/${encodeURIComponent(params.worksheetId)}/range(address='${params.address}')`,
+      headers: params.sessionId ? { "workbook-session-id": params.sessionId } : {},
+      ...(write ? { body: params.values ? { values: params.values } : { formulas: params.formulas } } : {}) };
+  } };
+}
+const createSessionSchema = createSchema({ itemId: driveItemId, persistChanges: { type: "boolean", required: true } });
+const closeSessionSchema = createSchema({ itemId: driveItemId, sessionId: { ...sessionId, required: true } });
+
+const microsoftExcelProvider = microsoftProvider(microsoftExcelDefinition, "common", "items.list", {
+  "ranges.get": rangeOperation(false),
+  "ranges.update": rangeOperation(true),
+  "sessions.create": { scopes: ["Files.ReadWrite"],
+    validateResult: (value) => typeof value?.id === "string" && value.id.length > 0 && typeof value.persistChanges === "boolean",
+    request(input) {
+      const { itemId, persistChanges } = validateSchemaPayload({ schema: createSessionSchema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "POST", url: `https://graph.microsoft.com/v1.0/me/drive/items/${encodeURIComponent(itemId)}/workbook/createSession`, body: { persistChanges } };
+    } },
+  "sessions.close": { scopes: ["Files.ReadWrite"], request(input) {
+    const { itemId, sessionId } = validateSchemaPayload({ schema: closeSessionSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "POST", url: `https://graph.microsoft.com/v1.0/me/drive/items/${encodeURIComponent(itemId)}/workbook/closeSession`, headers: { "workbook-session-id": sessionId } };
+  } },
+  "items.list": graphRead("Files.Read", { pageSize, folderId: { ...driveItemId, required: false } }, ({ pageSize, folderId }) => ({
+    pathname: folderId ? `/me/drive/items/${encodeURIComponent(folderId)}/children` : "/me/drive/root/children",
+    query: { $top: pageSize, $select: "id,name,file,folder,webUrl" }
+  })),
+  "worksheets.list": graphRead("Files.ReadWrite", { itemId: driveItemId }, ({ itemId }) => ({
+    pathname: `/me/drive/items/${encodeURIComponent(itemId)}/workbook/worksheets`
+  }))
+});
+export { microsoftExcelProvider };

package/src/server/microsoft-fabric.js

@@ -0,0 +1,81 @@
+import { isDeepStrictEqual } from "node:util";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { microsoftFabricDefinition, delegatedScope, serviceScope } from "../shared/microsoft-fabric.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const name = (value) => typeof value === "string" && /^[_A-Za-z][_0-9A-Za-z]*$/u.test(value);
+const validResult = (value) => object(value?.data) &&
+  (value.errors === undefined || (Array.isArray(value.errors) && value.errors.length === 0));
+const endpoint = (settings) => settings.graphqlEndpoint;
+const permissions = [delegatedScope, serviceScope];
+
+function fixedQuery(query, validateData) {
+  const operation = jsonOperation(endpoint, {}, (value) => validResult(value) && validateData(value.data), "POST");
+  return { ...operation, scopes: permissions, request(input, settings) {
+    return { ...operation.request(input, settings), body: { query } };
+  } };
+}
+
+const microsoftFabricProvider = Object.freeze({
+  ...microsoftFabricDefinition,
+  oauth: ({ tenantId }) => ({
+    issuer: `https://login.microsoftonline.com/${tenantId}/v2.0`,
+    authorization_endpoint: `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize`,
+    token_endpoint: `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`
+  }),
+  authorizationParameters: { response_mode: "query" },
+  apiOrigins: ["https://api.fabric.microsoft.com"], checkOperation: "connection.check",
+  async normalizeTokenResponse(response) {
+    if (!response.ok) {
+      let error;
+      try { error = (await response.clone().json())?.error; } catch { /* OAuth handles the response */ }
+      if (["interaction_required", "login_required", "consent_required"].includes(error)) {
+        throw new ConnectorError("connector_reconnect_required", "Microsoft requires a new sign-in or consent.", { statusCode: 401 });
+      }
+      return response;
+    }
+    let value;
+    try { value = await response.clone().json(); } catch { /* rejected below */ }
+    if (!Number.isSafeInteger(value?.expires_in) || value.expires_in <= 30 ||
+      (value.scope !== undefined && (typeof value.scope !== "string" || !/^[^\s]+(?: [^\s]+)*$/u.test(value.scope)))) {
+      throw new ConnectorError("connector_response_invalid", "Microsoft returned an invalid token grant.", { statusCode: 502 });
+    }
+    // Entra may return the permission name without the resource URI requested in consent.
+    if (value.scope?.split(" ").includes("GraphQLApi.Execute.All")) {
+      value.scope = value.scope.split(" ").map((scope) => scope === "GraphQLApi.Execute.All" ? delegatedScope : scope).join(" ");
+      return Response.json(value, { status: response.status });
+    }
+    return response;
+  },
+  operations: {
+    "connection.check": fixedQuery("query ConnectorFabricCheck { __typename }", (data) => name(data.__typename)),
+    "schema.types": fixedQuery("query ConnectorFabricTypes { __schema { types { name kind } queryType { name } mutationType { name } } }",
+      (data) => object(data.__schema) && Array.isArray(data.__schema.types) && data.__schema.types.every((type) => name(type?.name) &&
+        ["SCALAR", "OBJECT", "INTERFACE", "UNION", "ENUM", "INPUT_OBJECT", "LIST", "NON_NULL"].includes(type.kind)) &&
+        name(data.__schema.queryType?.name) && (data.__schema.mutationType === null || name(data.__schema.mutationType?.name))),
+    "graphql.execute": {
+      ...jsonOperation(endpoint, {
+        query: { type: "string", required: true, minLength: 1, maxLength: 65_536, validator: (value) => value.trim().length > 0 || "Provide a GraphQL document." },
+        variables: { type: "object", additionalProperties: true, validator(value) {
+          try {
+            const encoded = JSON.stringify(value);
+            if (encoded.length <= 65_536 && isDeepStrictEqual(value, JSON.parse(encoded))) return true;
+          } catch { /* invalid JSON values */ }
+          return "Use JSON variables within 65536 characters.";
+        } },
+        operationName: { type: "string", maxLength: 256, validator: (value) => name(value) || "Use a GraphQL operation name." }
+      }, validResult, "POST"), scopes: permissions
+    }
+  },
+  async exchange(address, options, { request }) {
+    const result = await request(address, options);
+    if (Array.isArray(result?.errors) && result.errors.length > 0) {
+      // A mutation can have taken effect before partial errors arrive. Do not replay or expose provider text.
+      throw new ConnectorError("connector_provider_failed", "Fabric could not complete the GraphQL document. Check its schema and permissions before retrying.", { statusCode: 502 });
+    }
+    return result;
+  }
+});
+
+export { microsoftFabricProvider };

package/src/server/microsoft-onedrive.js

@@ -0,0 +1,58 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { microsoftOneDriveDefinition } from "../shared/microsoft.js";
+import { graphRead, microsoftProvider, pageSize, driveItemId } from "./microsoft.js";
+
+const fields = "id,name,size,webUrl,file,folder,parentReference";
+const item = (value) => {
+  if (typeof value?.id !== "string" || typeof value.name !== "string") return false;
+  if (value["@microsoft.graph.downloadUrl"] === undefined) return true;
+  try {
+    const url = new URL(value["@microsoft.graph.downloadUrl"]);
+    return url.protocol === "https:" && !url.username && !url.password && !url.hash;
+  } catch { return false; }
+};
+const getSchema = createSchema({ itemId: driveItemId });
+const uploadSchema = createSchema({
+  parentId: driveItemId,
+  name: { type: "string", required: true, minLength: 1, maxLength: 255,
+    // eslint-disable-next-line no-control-regex -- Reject literal control characters in provider input.
+    validator: (value) => !/[\\/\x00-\x1f"*:<>?|]/u.test(value) && ![".", ".."].includes(value) || "Use a simple file name without reserved characters." },
+  bodyBase64: { type: "string", required: true, noTrim: true, maxLength: 6666668 },
+  conflictBehavior: { type: "string", enum: ["fail", "replace", "rename"], defaultTo: "fail" }
+});
+const base = microsoftProvider(microsoftOneDriveDefinition, "common", "items.list", {
+  "items.list": graphRead("Files.Read", { pageSize, folderId: { ...driveItemId, required: false } }, ({ pageSize, folderId }) => ({
+    pathname: folderId ? `/me/drive/items/${encodeURIComponent(folderId)}/children` : "/me/drive/root/children",
+    query: { $top: pageSize, $select: fields }
+  })),
+  "items.get": { scopes: ["Files.Read"], validateResult: item, request(input) {
+    const { itemId } = validateSchemaPayload({ schema: getSchema, mode: "replace" }, input, { statusCode: 422 });
+    const url = new URL(`https://graph.microsoft.com/v1.0/me/drive/items/${encodeURIComponent(itemId)}`);
+    url.searchParams.set("$select", `${fields},@microsoft.graph.downloadUrl`);
+    return { method: "GET", url: url.href };
+  } },
+  "files.upload": { scopes: ["Files.ReadWrite"], validateResult: item, request(input) {
+    const { parentId, name, bodyBase64, conflictBehavior } = validateSchemaPayload({ schema: uploadSchema, mode: "replace" }, input, { statusCode: 422 });
+    const body = Buffer.from(bodyBase64, "base64");
+    if (body.toString("base64") !== bodyBase64 || body.length > 5_000_000) {
+      throw new ConnectorError("connector_input_invalid", "Use standard padded base64 up to 5 MB; larger files need a native upload session.", { statusCode: 422 });
+    }
+    const url = new URL(`https://graph.microsoft.com/v1.0/me/drive/items/${encodeURIComponent(parentId)}:/${encodeURIComponent(name)}:/content`);
+    url.searchParams.set("@microsoft.graph.conflictBehavior", conflictBehavior);
+    return { method: "PUT", url: url.href, headers: { "Content-Type": "application/octet-stream" }, body };
+  } }
+});
+const microsoftOneDriveProvider = Object.freeze({ ...base,
+  async exchange(address, options, { request, fetchImpl }) {
+    if (options.method !== "PUT") return request(address, options);
+    const response = await fetchImpl(address, { ...options, credentials: "omit", redirect: "error" });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw Object.assign(new Error("OneDrive upload failed; inspect the folder before retrying."), { status: response.status });
+    }
+    return response.json();
+  }
+});
+export { microsoftOneDriveProvider };

package/src/server/microsoft-onenote.js

@@ -0,0 +1,52 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { microsoftOneNoteDefinition } from "../shared/microsoft.js";
+import { graphRead, microsoftProvider, pageSize } from "./microsoft.js";
+
+const id = { type: "string", required: true, minLength: 1, maxLength: 1024,
+  validator: value => /^[A-Za-z0-9!_{}:.-]+$/u.test(value) && value !== "." && value !== ".." || "Use the returned OneNote resource ID." };
+const text = { type: "string", required: true, minLength: 1, maxLength: 100000, noTrim: true };
+const escape = value => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+const createSchemaPage = createSchema({ sectionId: id, title: { ...text, maxLength: 255 }, text });
+const appendSchema = createSchema({ pageId: id, text });
+const contentSchema = createSchema({ pageId: id });
+const origin = "https://graph.microsoft.com/v1.0/me/onenote";
+const base = microsoftProvider(microsoftOneNoteDefinition, "common", "notebooks.list", {
+  "notebooks.list": graphRead("Notes.Read", {}, () => ({ pathname: "/me/onenote/notebooks" })),
+  "sections.list": graphRead("Notes.Read", { notebookId: id }, ({ notebookId }) => ({ pathname: `/me/onenote/notebooks/${encodeURIComponent(notebookId)}/sections` })),
+  "pages.list": graphRead("Notes.Read", { sectionId: id, pageSize }, ({ sectionId, pageSize }) => ({ pathname: `/me/onenote/sections/${encodeURIComponent(sectionId)}/pages`, query: { $top: pageSize } })),
+  "pages.content": { scopes: ["Notes.Read"], validateResult: value => typeof value?.html === "string", request(input) {
+    const { pageId } = validateSchemaPayload({ schema: contentSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "GET", url: `${origin}/pages/${encodeURIComponent(pageId)}/content?includeIDs=true` };
+  } },
+  "pages.create": { scopes: ["Notes.Create", "Notes.ReadWrite", "Notes.ReadWrite.All"], validateResult: value => typeof value?.id === "string", request(input) {
+    const { sectionId, title, text } = validateSchemaPayload({ schema: createSchemaPage, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "POST", url: `${origin}/sections/${encodeURIComponent(sectionId)}/pages`, headers: { "Content-Type": "text/html" },
+      body: `<!DOCTYPE html><html><head><title>${escape(title)}</title></head><body><p>${escape(text).replaceAll("\n", "<br />")}</p></body></html>` };
+  } },
+  "pages.append": { scopes: ["Notes.ReadWrite", "Notes.ReadWrite.All"], request(input) {
+    const { pageId, text } = validateSchemaPayload({ schema: appendSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "PATCH", url: `${origin}/pages/${encodeURIComponent(pageId)}/content`,
+      body: [{ target: "body", action: "append", content: `<p>${escape(text).replaceAll("\n", "<br />")}</p>` }] };
+  } }
+});
+const microsoftOneNoteProvider = Object.freeze({ ...base,
+  async exchange(address, options, { request, fetchImpl }) {
+    const content = options.method === "GET" && new URL(address).pathname.endsWith("/content");
+    const create = new Headers(options.headers).get("content-type") === "text/html";
+    if (!content && !create) return request(address, options);
+    const response = await fetchImpl(address, { ...options, credentials: "omit", redirect: "error" });
+    if (!response.ok) { await response.body?.cancel(); throw Object.assign(new Error("OneNote request failed."), { status: response.status }); }
+    if (create) return response.json();
+    const reader = response.body?.getReader(); const chunks = []; let size = 0;
+    if (reader) try { while (true) {
+      const { done, value } = await reader.read(); if (done) break;
+      size += value.byteLength;
+      if (size > 1048576) { await reader.cancel(); throw new ConnectorError("connector_response_too_large", "Use the native OneNote client for pages above 1 MiB.", { statusCode: 413 }); }
+      chunks.push(value);
+    } } finally { reader.releaseLock(); }
+    return { html: Buffer.concat(chunks).toString("utf8") };
+  }
+});
+export { microsoftOneNoteProvider };

package/src/server/microsoft-outlook.js

@@ -0,0 +1,58 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { microsoftOutlookDefinition } from "../shared/microsoft.js";
+import { graphRead, microsoftProvider, pageSize } from "./microsoft.js";
+
+const id = { type: "string", required: true, minLength: 1, maxLength: 2048,
+  validator: value => /^[A-Za-z0-9_+=-]+$/u.test(value) || "Use the returned Outlook resource ID." };
+const text = { type: "string", required: true, minLength: 1, maxLength: 100000, noTrim: true };
+const instant = { type: "string", required: true, maxLength: 30,
+  validator: value => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u.test(value) && Number.isFinite(Date.parse(value)) || "Use a UTC ISO timestamp ending in Z." };
+const resource = value => typeof value?.id === "string";
+function operation(scopes, fields, destination, validateResult = resource) {
+  const schema = createSchema(fields);
+  return { scopes, validateResult, request(input) {
+    return destination(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+  } };
+}
+const url = path => `https://graph.microsoft.com/v1.0/me${path}`;
+
+const base = microsoftProvider(microsoftOutlookDefinition, "common", "folders.list", {
+  "messages.get": operation(["Mail.Read"], { messageId: id }, ({ messageId }) => ({ method: "GET", url: url(`/messages/${encodeURIComponent(messageId)}`), headers: { Prefer: 'outlook.body-content-type="text"' } }), value => resource(value) && typeof value.body?.content === "string"),
+  "attachments.list": graphRead("Mail.Read", { messageId: id }, ({ messageId }) => ({ pathname: `/me/messages/${encodeURIComponent(messageId)}/attachments` })),
+  "attachments.get": operation(["Mail.Read"], { messageId: id, attachmentId: id }, ({ messageId, attachmentId }) => ({ method: "GET", url: url(`/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`) }), value => resource(value) && value["@odata.type"] === "#microsoft.graph.fileAttachment" && typeof value.contentBytes === "string" && value.contentBytes.length <= 6666668),
+  "messages.setRead": operation(["Mail.ReadWrite"], { messageId: id, isRead: { type: "boolean", required: true } }, ({ messageId, isRead }) => ({ method: "PATCH", url: url(`/messages/${encodeURIComponent(messageId)}`), body: { isRead } })),
+  "messages.move": operation(["Mail.ReadWrite"], { messageId: id, destinationId: id }, ({ messageId, destinationId }) => ({ method: "POST", url: url(`/messages/${encodeURIComponent(messageId)}/move`), body: { destinationId } })),
+  "messages.send": operation(["Mail.Send"], {
+    subject: { ...text, maxLength: 998 }, text,
+    to: { type: "array", required: true, validator: value => value.length > 0 && value.length <= 20 && value.every(address => typeof address === "string" && address.length <= 320 && /^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/u.test(address)) || "Supply 1–20 recipient email addresses." }
+  }, ({ subject, text, to }) => ({ method: "POST", url: url("/sendMail"), body: { message: { subject, body: { contentType: "Text", content: text }, toRecipients: to.map(address => ({ emailAddress: { address } })) }, saveToSentItems: true } }), value => value?.accepted === true),
+  "calendars.list": { ...graphRead("Calendars.Read", {}, () => ({ pathname: "/me/calendars" })), scopes: ["Calendars.Read", "Calendars.ReadWrite"] },
+  "events.list": { ...graphRead("Calendars.Read", { calendarId: id, pageSize }, ({ calendarId, pageSize }) => ({ pathname: `/me/calendars/${encodeURIComponent(calendarId)}/events`, query: { $top: pageSize } })), scopes: ["Calendars.Read", "Calendars.ReadWrite"] },
+  "events.create": operation(["Calendars.ReadWrite"], { calendarId: id, subject: { ...text, maxLength: 255 }, start: instant, end: instant }, ({ calendarId, subject, start, end }) => {
+    if (Date.parse(end) <= Date.parse(start)) throw new ConnectorError("connector_input_invalid", "End must follow start.", { statusCode: 422 });
+    return { method: "POST", url: url(`/calendars/${encodeURIComponent(calendarId)}/events`), body: { subject, start: { dateTime: start.slice(0, -1), timeZone: "UTC" }, end: { dateTime: end.slice(0, -1), timeZone: "UTC" } } };
+  }),
+  "folders.list": graphRead("Mail.Read", {
+    pageSize, includeHiddenFolders: { type: "boolean", defaultTo: false }
+  }, (params) => ({ pathname: "/me/mailFolders", query: {
+    $top: params.pageSize, includeHiddenFolders: params.includeHiddenFolders,
+    $select: "id,displayName,childFolderCount,unreadItemCount,totalItemCount"
+  } })),
+  "inbox.list": graphRead("Mail.Read", { pageSize }, (params) => ({
+    pathname: "/me/mailFolders/inbox/messages", query: {
+      $top: params.pageSize, $select: "id,subject,from,receivedDateTime,isRead"
+    }
+  }))
+});
+const microsoftOutlookProvider = Object.freeze({ ...base,
+  async exchange(address, options, { request, fetchImpl }) {
+    if (new URL(address).pathname !== "/v1.0/me/sendMail") return request(address, options);
+    const response = await fetchImpl(address, { ...options, body: JSON.stringify(options.body), headers: { ...options.headers, "Content-Type": "application/json" }, credentials: "omit", redirect: "error" });
+    await response.body?.cancel();
+    if (response.status !== 202) throw Object.assign(new Error("Outlook did not accept the message."), { status: response.ok ? 502 : response.status });
+    return { accepted: true };
+  }
+});
+export { microsoftOutlookProvider };

package/src/server/microsoft-powerpoint.js

@@ -0,0 +1,5 @@
+import { microsoftPowerPointDefinition } from "../shared/microsoft.js";
+import { microsoftDocumentProvider } from "./microsoft.js";
+
+const microsoftPowerPointProvider = microsoftDocumentProvider(microsoftPowerPointDefinition, ["ppt", "pptx", "pptm", "pot", "potx", "potm", "pps", "ppsx", "ppsm"]);
+export { microsoftPowerPointProvider };

package/src/server/microsoft-sharepoint.js

@@ -0,0 +1,46 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { microsoftSharePointDefinition } from "../shared/microsoft.js";
+import { graphRead, microsoftProvider, driveItemId, pageSize } from "./microsoft.js";
+import { microsoftOneDriveProvider } from "./microsoft-onedrive.js";
+
+const siteId = { type: "string", required: true, minLength: 1, maxLength: 512,
+  validator: value => /^[A-Za-z0-9.,_-]+$/u.test(value) && value !== "." && value !== ".." || "Use the site's returned ID, not its URL." };
+const listId = driveItemId;
+const listFields = { type: "object", required: true, additionalProperties: true, validator: value => {
+  const entries = Object.entries(value);
+  return entries.length > 0 && entries.length <= 100 && JSON.stringify(value).length <= 65536 && entries.every(([key, cell]) =>
+    /^[A-Za-z_][A-Za-z0-9_]*$/u.test(key) && (cell === null || ["string", "boolean"].includes(typeof cell) || typeof cell === "number" && Number.isFinite(cell))) || "Use up to 100 internal column names with scalar values (64 KiB maximum).";
+} };
+const createItemSchema = createSchema({ siteId, listId, fields: listFields });
+const updateItemSchema = createSchema({ siteId, listId, itemId: driveItemId, fields: listFields,
+  eTag: { type: "string", required: true, minLength: 1, maxLength: 512, validator: value => !/[\r\n]/u.test(value) && value !== "*" || "Use the item's current ETag, not a wildcard." } });
+const driveSchema = createSchema({ driveId: driveItemId });
+function fileOperation(name, scopes) {
+  const source = microsoftOneDriveProvider.operations[name];
+  return { ...source, scopes, request(input) {
+    const { driveId, ...values } = input || {};
+    const valid = validateSchemaPayload({ schema: driveSchema, mode: "replace" }, { driveId }, { statusCode: 422 });
+    const result = source.request(values);
+    return { ...result, url: result.url.replace("/me/drive/items/", `/drives/${encodeURIComponent(valid.driveId)}/items/`) };
+  } };
+}
+const base = microsoftProvider(microsoftSharePointDefinition, "organizations", "sites.search", {
+  "sites.search": graphRead("Sites.Read.All", { search: { type: "string", required: true, minLength: 1, maxLength: 1024 } }, ({ search }) => ({ pathname: "/sites", query: { search } })),
+  "libraries.list": graphRead("Sites.Read.All", { siteId }, ({ siteId }) => ({ pathname: `/sites/${encodeURIComponent(siteId)}/drives` })),
+  "files.list": graphRead("Sites.Read.All", { driveId: driveItemId, folderId: { ...driveItemId, required: false }, pageSize }, ({ driveId, folderId, pageSize }) => ({ pathname: `/drives/${encodeURIComponent(driveId)}/${folderId ? `items/${encodeURIComponent(folderId)}` : "root"}/children`, query: { $top: pageSize } })),
+  "files.get": fileOperation("items.get", ["Sites.Read.All"]),
+  "files.upload": fileOperation("files.upload", ["Sites.ReadWrite.All"]),
+  "lists.list": graphRead("Sites.Read.All", { siteId }, ({ siteId }) => ({ pathname: `/sites/${encodeURIComponent(siteId)}/lists` })),
+  "listItems.list": graphRead("Sites.Read.All", { siteId, listId, pageSize }, ({ siteId, listId, pageSize }) => ({ pathname: `/sites/${encodeURIComponent(siteId)}/lists/${encodeURIComponent(listId)}/items`, query: { $expand: "fields", $top: pageSize } })),
+  "listItems.create": { scopes: ["Sites.ReadWrite.All"], validateResult: value => typeof value?.id === "string", request(input) {
+    const { siteId, listId, fields } = validateSchemaPayload({ schema: createItemSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "POST", url: `https://graph.microsoft.com/v1.0/sites/${encodeURIComponent(siteId)}/lists/${encodeURIComponent(listId)}/items`, body: { fields } };
+  } },
+  "listItems.update": { scopes: ["Sites.ReadWrite.All"], validateResult: value => value !== null && typeof value === "object" && !Array.isArray(value), request(input) {
+    const { siteId, listId, itemId, fields, eTag } = validateSchemaPayload({ schema: updateItemSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "PATCH", url: `https://graph.microsoft.com/v1.0/sites/${encodeURIComponent(siteId)}/lists/${encodeURIComponent(listId)}/items/${encodeURIComponent(itemId)}/fields`, headers: { "If-Match": eTag }, body: fields };
+  } }
+});
+const microsoftSharePointProvider = Object.freeze({ ...base, exchange: microsoftOneDriveProvider.exchange });
+export { microsoftSharePointProvider };

package/src/server/microsoft-teams.js

@@ -0,0 +1,29 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { microsoftTeamsDefinition } from "../shared/microsoft.js";
+import { graphRead, microsoftProvider } from "./microsoft.js";
+
+const id = { type: "string", required: true, minLength: 1, maxLength: 1024,
+  validator: value => /^[A-Za-z0-9_:@.=-]+$/u.test(value) && value !== "." && value !== ".." || "Use the returned Teams resource ID." };
+const channel = { teamId: id, channelId: id };
+const pageSize = { type: "integer", min: 1, max: 50, defaultTo: 25 };
+const channelPath = ({ teamId, channelId }) => `/teams/${encodeURIComponent(teamId)}/channels/${encodeURIComponent(channelId)}`;
+function send(scope, fields, path) {
+  const schema = createSchema({ ...fields, text: { type: "string", required: true, minLength: 1, maxLength: 20000, noTrim: true } });
+  return { scopes: [scope], validateResult: value => typeof value?.id === "string", request(input) {
+    const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    return { method: "POST", url: `https://graph.microsoft.com/v1.0${path(values)}`, body: { body: { contentType: "text", content: values.text } } };
+  } };
+}
+const microsoftTeamsProvider = microsoftProvider(microsoftTeamsDefinition, "organizations", "teams.list", {
+  "teams.list": graphRead("Team.ReadBasic.All", {}, () => ({ pathname: "/me/joinedTeams" })),
+  "channels.list": graphRead("Channel.ReadBasic.All", { teamId: id }, ({ teamId }) => ({ pathname: `/teams/${encodeURIComponent(teamId)}/channels` })),
+  "messages.list": graphRead("ChannelMessage.Read.All", { ...channel, pageSize }, input => ({ pathname: `${channelPath(input)}/messages`, query: { $top: input.pageSize } })),
+  "replies.list": graphRead("ChannelMessage.Read.All", { ...channel, messageId: id }, input => ({ pathname: `${channelPath(input)}/messages/${encodeURIComponent(input.messageId)}/replies` })),
+  "messages.send": send("ChannelMessage.Send", channel, input => `${channelPath(input)}/messages`),
+  "replies.send": send("ChannelMessage.Send", { ...channel, messageId: id }, input => `${channelPath(input)}/messages/${encodeURIComponent(input.messageId)}/replies`),
+  "chats.list": graphRead("Chat.ReadWrite", {}, () => ({ pathname: "/me/chats" })),
+  "chatMessages.list": graphRead("Chat.ReadWrite", { chatId: id, pageSize }, ({ chatId, pageSize }) => ({ pathname: `/chats/${encodeURIComponent(chatId)}/messages`, query: { $top: pageSize } })),
+  "chatMessages.send": send("Chat.ReadWrite", { chatId: id }, ({ chatId }) => `/chats/${encodeURIComponent(chatId)}/messages`)
+});
+export { microsoftTeamsProvider };

package/src/server/microsoft-word.js

@@ -0,0 +1,5 @@
+import { microsoftWordDefinition } from "../shared/microsoft.js";
+import { microsoftDocumentProvider } from "./microsoft.js";
+
+const microsoftWordProvider = microsoftDocumentProvider(microsoftWordDefinition, ["doc", "docx", "docm", "dot", "dotx", "dotm"]);
+export { microsoftWordProvider };

package/src/server/microsoft.js

@@ -0,0 +1,88 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+
+const graphOrigin = "https://graph.microsoft.com";
+const pageSize = { type: "integer", min: 1, max: 100, defaultTo: 25 };
+const driveItemId = {
+  type: "string", required: true, minLength: 1, maxLength: 1024,
+  validator: (value) => /^[a-zA-Z0-9_!-]+$/u.test(value) || "Enter the drive item's ID, not a file URL or path."
+};
+
+function graphRead(permission, fields, destination) {
+  const schema = createSchema({ ...fields, nextLink: { type: "string", minLength: 1, maxLength: 16384 } });
+  return {
+    scopes: [permission],
+    validateResult: (value) => Array.isArray(value?.value) &&
+      (value["@odata.nextLink"] === undefined || typeof value["@odata.nextLink"] === "string"),
+    request(input) {
+      const params = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const { pathname, query = {} } = destination(params);
+      const url = new URL(`/v1.0${pathname}`, graphOrigin);
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined) url.searchParams.set(key, String(value));
+      }
+      if (!params.nextLink) return { method: "GET", url: url.href };
+      // Graph owns the opaque paging query. A continuation must stay on this operation's resource.
+      const continuation = createSchema({ nextLink: {
+        type: "string", required: true,
+        validator(value) {
+          try {
+            const next = new URL(value);
+            return (next.origin === url.origin && next.pathname === url.pathname &&
+              !next.username && !next.password && !next.hash) || "Use the next link returned for this operation and resource.";
+          } catch { return "Use the next link returned for this operation and resource."; }
+        }
+      } });
+      validateSchemaPayload({ schema: continuation, mode: "replace" }, { nextLink: params.nextLink }, { statusCode: 422 });
+      return { method: "GET", url: params.nextLink };
+    }
+  };
+}
+
+function microsoftProvider(definition, authority, checkOperation, operations) {
+  return Object.freeze({
+    ...definition,
+    oauth: ({ tenantId = authority } = {}) => ({
+      issuer: "https://login.microsoftonline.com/{tenantid}/v2.0",
+      authorization_endpoint: `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize`,
+      token_endpoint: `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`
+    }),
+    authorizationParameters: { response_mode: "query" }, apiOrigins: [graphOrigin], checkOperation, operations
+  });
+}
+
+function microsoftDocumentProvider(definition, extensions) {
+  const fields = "id,name,size,webUrl,file,folder,parentReference,lastModifiedDateTime,eTag";
+  const facet = (value) => value === undefined || (value !== null && typeof value === "object" && !Array.isArray(value));
+  const metadata = (value) => typeof value?.id === "string" && value.id.length > 0 &&
+    typeof value.name === "string" && value.name.length > 0 && facet(value.file) && facet(value.folder);
+  const matches = (value) => value?.file && extensions.includes(value.name.split(".").at(-1).toLowerCase());
+  const list = graphRead("Files.Read", { pageSize, folderId: { ...driveItemId, required: false } }, (params) => ({
+    pathname: params.folderId ? `/me/drive/items/${encodeURIComponent(params.folderId)}/children` : "/me/drive/root/children",
+    query: { $top: params.pageSize, $select: fields }
+  }));
+  const itemSchema = createSchema({ itemId: driveItemId });
+  const provider = microsoftProvider(definition, "common", "items.list", {
+    "items.list": { ...list, validateResult: (value) => list.validateResult(value) && value.value.every(metadata) },
+    "items.get": { scopes: ["Files.Read"], validateResult: metadata, request(input) {
+      const { itemId } = validateSchemaPayload({ schema: itemSchema, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(`/v1.0/me/drive/items/${encodeURIComponent(itemId)}`, graphOrigin);
+      url.searchParams.set("$select", fields);
+      return { method: "GET", url: url.href };
+    } }
+  });
+  return Object.freeze({ ...provider, async exchange(address, options, { request }) {
+    const result = await request(address, options);
+    if (new URL(address).pathname.endsWith("/children")) {
+      if (!provider.operations["items.list"].validateResult(result)) {
+        throw new ConnectorError("connector_response_invalid", "Microsoft returned an invalid file list.", { statusCode: 502 });
+      }
+      return { ...result, value: result.value.filter((item) => item.folder || matches(item)) };
+    }
+    if (!metadata(result)) throw new ConnectorError("connector_response_invalid", "Microsoft returned invalid file metadata.", { statusCode: 502 });
+    if (!matches(result)) throw new ConnectorError("connector_document_type_invalid", `Choose a ${definition.name} file.`);
+    return result;
+  } });
+}
+export { graphRead, microsoftProvider, microsoftDocumentProvider, pageSize, driveItemId };

package/src/server/miro.js

@@ -0,0 +1,29 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { miroDefinition } from "../shared/miro.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+
+const resource = "https://mcp.miro.com/";
+const oauth = Object.freeze({
+  issuer: resource, authorization_endpoint: "https://mcp.miro.com/authorize",
+  token_endpoint: "https://mcp.miro.com/token", registration_endpoint: "https://mcp.miro.com/register",
+  response_types_supported: ["code"]
+});
+const miroProvider = Object.freeze({
+  ...miroDefinition, oauth, oauthResource: resource, apiOrigins: ["https://mcp.miro.com"],
+  checkOperation: "tools.list", exchange: exchangeMcp, operations: mcpOperations(() => resource)
+});
+const registrationSchema = createSchema({
+  ...mcpRegistrationFields,
+  scopes: { type: "array", required: true, minLength: 1,
+    items: { type: "string", enum: miroDefinition.scopes.map((scope) => scope.value) },
+    validator: (scopes) => scopes.length > 0 && new Set(scopes).size === scopes.length || "Select at least one permission and include each once." }
+});
+
+async function registerMiroClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Miro", oauth, values, options);
+}
+
+export { miroProvider, registerMiroClient };

package/src/server/n8n.js

@@ -0,0 +1,78 @@
+import { createSchema } from "json-rest-schema";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { discoverOAuthProtectedResourceMetadata, discoverAuthorizationServerMetadata } from "@modelcontextprotocol/sdk/client/auth.js";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+import { n8nDefinition, validN8nOAuthDiscovery } from "../shared/mcp.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+
+const n8nProvider = Object.freeze({
+  ...n8nDefinition,
+  apiOrigins: (settings) => [new URL(settings.serverUrl).origin],
+  oauth: (settings) => {
+    const discovery = settings.oauthDiscovery;
+    if (!validN8nOAuthDiscovery(discovery) || discovery.resource !== new URL(settings.serverUrl).href) {
+      throw new ConnectorError("connector_discovery_required", "Discover OAuth settings for this exact n8n MCP URL before connecting.");
+    }
+    return discovery.oauth;
+  },
+  oauthResource: (settings) => new URL(settings.serverUrl).href,
+  apiKey: { headers: (token) => ({ Authorization: `Bearer ${token}` }) },
+  checkOperation: "tools.list",
+  exchange: exchangeMcp,
+  operations: mcpOperations((settings) => new URL(settings.serverUrl).href)
+});
+
+// The trusted setup host owns outbound-network policy, including private instances.
+// Discovery returns public metadata only; it never registers or sends credentials.
+async function discoverN8nOAuth({ serverUrl }, { fetchImpl = globalThis.fetch, signal } = {}) {
+  const settings = validateSchemaPayload({ schema: n8nDefinition.settingsSchema, mode: "replace" }, { serverUrl }, { statusCode: 422 });
+  const resource = new URL(settings.serverUrl).href;
+  const requestSignal = AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(15000)]);
+  let permittedOrigin = new URL(resource).origin;
+  const fetchFn = async (address, options) => {
+    const url = new URL(address);
+    if (url.protocol !== "https:" || url.origin !== permittedOrigin || url.username || url.password || url.search || url.hash ||
+      !url.pathname.includes("/.well-known/") || options?.method && options.method !== "GET") throw new Error("Invalid discovery destination.");
+    requestSignal.throwIfAborted();
+    return fetchImpl(url.href, { ...options, method: "GET", credentials: "omit", redirect: "error", signal: requestSignal });
+  };
+  try {
+    const protectedResource = await discoverOAuthProtectedResourceMetadata(resource, undefined, fetchFn);
+    if (protectedResource.resource !== resource || protectedResource.authorization_servers?.length !== 1) throw new Error("Ambiguous resource authority.");
+    const issuer = new URL(protectedResource.authorization_servers[0]);
+    if (issuer.protocol !== "https:" || issuer.username || issuer.password || issuer.search || issuer.hash) throw new Error("Invalid issuer.");
+    permittedOrigin = issuer.origin;
+    const metadata = await discoverAuthorizationServerMetadata(issuer, { fetchFn });
+    const scopes = protectedResource.scopes_supported || metadata?.scopes_supported || [];
+    const discovery = { resource, oauth: metadata, scopes: [...scopes] };
+    if (metadata?.issuer !== protectedResource.authorization_servers[0] || !validN8nOAuthDiscovery(discovery)) {
+      throw new Error("Unsupported n8n OAuth metadata.");
+    }
+    return discovery;
+  } catch {
+    if (requestSignal.aborted) throw new ConnectorError("connector_discovery_interrupted", "n8n OAuth discovery was interrupted.");
+    throw new ConnectorError("connector_discovery_failed", "n8n OAuth discovery failed. Check the MCP URL, advertised authority and supported server version.", { statusCode: 502 });
+  }
+}
+
+const registrationSchema = createSchema({
+  ...mcpRegistrationFields,
+  serverUrl: { type: "string", required: true, minLength: 1, maxLength: 2048 },
+  scopes: { type: "array", required: true, minLength: 1,
+    items: { type: "string", minLength: 1, maxLength: 200 },
+    validator: (values) => new Set(values).size === values.length || "Select each permission once." }
+});
+
+// The privileged setup caller owns authorization and private storage of this result.
+async function registerN8nClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  const discovery = await discoverN8nOAuth({ serverUrl: values.serverUrl }, options);
+  if (values.scopes.some((scope) => !discovery.scopes.includes(scope))) {
+    throw new ConnectorError("connector_scope_unavailable", "Select only permissions advertised by this n8n MCP server.", { statusCode: 422 });
+  }
+  const client = await registerMcpClient("n8n", discovery.oauth, values, options);
+  return { ...client, ...discovery, requestedScopes: [...values.scopes] };
+}
+
+export { n8nProvider, discoverN8nOAuth, registerN8nClient };