@jskit-ai/connectors-catalog 0.1.1

package/src/server/wordpress-com.js

@@ -0,0 +1,236 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { wordpressComDefinition } from "../shared/wordpress-com.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const postsSchema = createSchema({
+  siteId: { type: "integer", required: true, min: 1, max: Number.MAX_SAFE_INTEGER },
+  number: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  page_handle: { type: "string", minLength: 1, maxLength: 4096 },
+  search: { type: "string", minLength: 1, maxLength: 500 },
+  status: { type: "string", enum: ["publish", "private", "draft", "pending", "future", "trash", "any"], defaultTo: "publish" },
+  context: { type: "string", enum: ["display", "edit"], defaultTo: "display" },
+  type: { type: "string", enum: ["post", "page"] }
+});
+
+const resourceId = { type: "integer", required: true, min: 1, max: Number.MAX_SAFE_INTEGER };
+const batchSchema = createSchema({
+  siteId: resourceId,
+  resources: { type: "array", required: true, items: { type: "string", enum: ["posts", "media", "comments", "categories", "tags", "stats"] },
+    validator: values => values.length >= 1 && values.length <= 6 && new Set(values).size === values.length || "Select one to six distinct site resources." }
+});
+const editContext = { type: "string", enum: ["display", "edit"], defaultTo: "edit" };
+const contentFields = {
+  title: { type: "string", noTrim: true, maxLength: 10000 },
+  content: { type: "string", noTrim: true, maxLength: 1000000 },
+  excerpt: { type: "string", noTrim: true, maxLength: 100000 },
+  slug: { type: "string", minLength: 1, maxLength: 200 },
+  status: { type: "string", enum: ["draft", "pending", "publish", "private"] },
+  type: { type: "string", enum: ["post", "page"] },
+  parent: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+  categories: { type: "array", items: { type: "integer", min: 1, max: Number.MAX_SAFE_INTEGER }, validator: values => values.length <= 100 || "Use at most 100 category IDs." },
+  tags: { type: "array", items: { type: "integer", min: 1, max: Number.MAX_SAFE_INTEGER }, validator: values => values.length <= 100 || "Use at most 100 tag IDs." },
+  featured_image: { type: "string", maxLength: 20, validator: value => value === "" || /^[1-9][0-9]*$/u.test(value) || "Use an attachment ID or an empty string to clear it." },
+  publicize: { type: "boolean" }
+};
+const postRecord = value => Number.isSafeInteger(value?.ID) && value.ID > 0 &&
+  Number.isSafeInteger(value.site_ID) && value.site_ID > 0 && typeof value.title === "string" && typeof value.status === "string";
+function siteOperation(action, fields, { resource = "posts", scope = resource, read = false, changesRequired = false, collection = false, validateResult = postRecord } = {}) {
+  const schema = createSchema({ siteId: resourceId, ...fields, context: editContext });
+  return {
+    scopes: [scope],
+    request(input) {
+      const { siteId, postId, mediaId, commentId, termSlug, context, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      delete values.confirmDeletion;
+      if (changesRequired && !Object.keys(values).length) {
+        throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+      }
+      const target = termSlug === undefined ? postId ?? mediaId ?? commentId ?? (collection ? "" : "new") : `slug:${encodeURIComponent(termSlug)}`;
+      const url = new URL(`https://public-api.wordpress.com/rest/v1.1/sites/${siteId}/${resource}/${target}${action ? `/${action}` : ""}`);
+      url.searchParams.set("context", context);
+      if (read) {
+        for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
+        return { method: "GET", url: url.href };
+      }
+      const body = new URLSearchParams();
+      for (const [key, value] of Object.entries(values)) body.set(key, String(value));
+      return { method: "POST", url: url.href, headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: body.toString() };
+    },
+    validateResult
+  };
+}
+
+const mediaRecord = value => Number.isSafeInteger(value?.ID) && value.ID > 0 && typeof value.URL === "string" && typeof value.title === "string";
+const commentRecord = value => Number.isSafeInteger(value?.ID) && value.ID > 0 && typeof value.content === "string" && typeof value.status === "string";
+const commentOptions = { resource: "comments", validateResult: commentRecord };
+const commentText = { type: "string", required: true, minLength: 1, maxLength: 100000, noTrim: true };
+const termRecord = value => Number.isSafeInteger(value?.ID) && value.ID > 0 && typeof value.name === "string" && typeof value.slug === "string";
+const termSlug = { type: "string", required: true, minLength: 1, maxLength: 600,
+  validator: value => !/[\\/\p{Cc}]/u.test(value) && ![".", ".."].includes(value) || "Use a term slug, not a path." };
+const taxonomyOperations = Object.fromEntries(["categories", "tags"].flatMap(resource => {
+  const fields = {
+    name: { type: "string", minLength: 1, maxLength: 200 },
+    description: { type: "string", maxLength: 100000, noTrim: true },
+    ...(resource === "categories" ? { parent: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER } } : {})
+  };
+  const options = { resource, scope: "taxonomy", validateResult: termRecord };
+  return [
+    [`${resource}.list`, siteOperation("", {
+      number: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
+      page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+      search: { type: "string", minLength: 1, maxLength: 500 }
+    }, { ...options, read: true, collection: true,
+      validateResult: value => Number.isSafeInteger(value?.found) && value.found >= 0 && Array.isArray(value[resource]) && value[resource].every(termRecord) })],
+    [`${resource}.get`, siteOperation("", { termSlug }, { ...options, read: true })],
+    [`${resource}.create`, siteOperation("", { ...fields, name: { ...fields.name, required: true } }, options)],
+    [`${resource}.update`, siteOperation("", { termSlug, ...fields }, { ...options, changesRequired: true })],
+    [`${resource}.delete`, siteOperation("delete", {
+      termSlug, confirmDeletion: { type: "boolean", required: true, validator: value => value === true || "Confirm removal of this category or tag." }
+    }, options)]
+  ];
+}));
+const mediaOptions = { resource: "media", validateResult: mediaRecord };
+const mediaFields = {
+  title: contentFields.title, caption: contentFields.excerpt, description: contentFields.content,
+  alt: { type: "string", maxLength: 10000, noTrim: true },
+  parent_id: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER }
+};
+const mediaUploadSchema = createSchema({
+  siteId: resourceId, ...mediaFields,
+  filename: { type: "string", required: true, minLength: 1, maxLength: 255,
+    validator: value => !/[\\/\p{Cc}"]/u.test(value) && ![".", ".."].includes(value) || "Use a filename without paths, quotes or control characters." },
+  mimeType: { type: "string", required: true, maxLength: 150, pattern: "^[a-zA-Z0-9.+-]+/[a-zA-Z0-9.+-]+$" },
+  contentBase64: { type: "string", required: true, minLength: 4, maxLength: 6990508, noTrim: true }
+});
+
+const wordpressComProvider = Object.freeze({
+  ...wordpressComDefinition,
+  oauth: {
+    issuer: "https://public-api.wordpress.com",
+    authorization_endpoint: "https://public-api.wordpress.com/oauth2/authorize",
+    token_endpoint: "https://public-api.wordpress.com/oauth2/token"
+  },
+  scopeSeparator: ",",
+  apiOrigins: ["https://public-api.wordpress.com"], checkOperation: "profile.read",
+  grantedScopesFromVerification(profile, { clientId }) {
+    if (String(profile.token_client_id) !== clientId) {
+      throw new ConnectorError("connector_response_invalid", "The verified token belongs to a different application.", { statusCode: 502 });
+    }
+    return profile.token_scope;
+  },
+  operations: {
+    ...taxonomyOperations,
+    "batch.read": {
+      scopes: ["batch"],
+      request(input) {
+        const { siteId, resources } = validateSchemaPayload({ schema: batchSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL("https://public-api.wordpress.com/rest/v1.3/batch/");
+        for (const resource of resources) {
+          url.searchParams.append("urls[]", `/sites/${siteId}/${resource}?context=edit${resource === "stats" ? "" : "&number=20"}`);
+        }
+        return { method: "GET", url: url.href };
+      },
+      validateResult: value => value !== null && typeof value === "object" && !Array.isArray(value) &&
+        Object.keys(value).length > 0 && Object.values(value).every(entry => entry !== null && typeof entry === "object")
+    },
+    "stats.read": siteOperation("", {}, {
+      resource: "stats", read: true, collection: true,
+      validateResult: value => typeof value?.date === "string" && value.stats !== null && typeof value.stats === "object" &&
+        value.visits !== null && typeof value.visits === "object"
+    }),
+    "comments.list": siteOperation("", {
+      number: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+      status: { type: "string", enum: ["approved", "unapproved", "spam", "trash", "all"], defaultTo: "approved" },
+      order: { type: "string", enum: ["ASC", "DESC"], defaultTo: "DESC" }
+    }, { ...commentOptions, read: true, collection: true,
+      validateResult: value => Number.isSafeInteger(value?.found) && value.found >= 0 && Array.isArray(value.comments) && value.comments.every(commentRecord) }),
+    "comments.get": siteOperation("", { commentId: resourceId }, { ...commentOptions, read: true }),
+    "comments.create": siteOperation("replies/new", { postId: resourceId, content: commentText }, {
+      resource: "posts", scope: "comments", validateResult: commentRecord
+    }),
+    "comments.reply": siteOperation("replies/new", { commentId: resourceId, content: commentText }, commentOptions),
+    "comments.update": siteOperation("", {
+      commentId: resourceId, content: { ...commentText, required: false },
+      status: { type: "string", required: true, enum: ["approved", "unapproved", "spam", "unspam", "trash", "untrash"] }
+    }, commentOptions),
+    "comments.delete": siteOperation("delete", {
+      commentId: resourceId,
+      confirmDeletion: { type: "boolean", required: true, validator: value => value === true || "Confirm deletion, which may permanently remove the comment." }
+    }, commentOptions),
+    "posts.get": siteOperation("", { postId: resourceId }, { read: true }),
+    "posts.create": siteOperation("", {
+      ...contentFields,
+      title: { ...contentFields.title, required: true, minLength: 1 },
+      status: { ...contentFields.status, defaultTo: "draft" },
+      type: { ...contentFields.type, defaultTo: "post" },
+      publicize: { ...contentFields.publicize, defaultTo: false }
+    }),
+    "posts.update": siteOperation("", { ...contentFields, postId: resourceId }, { changesRequired: true }),
+    "posts.delete": siteOperation("delete", {
+      postId: resourceId,
+      confirmDeletion: { type: "boolean", required: true, validator: value => value === true || "Confirm deletion, which may be permanent on this site or for an already-trashed post." }
+    }),
+    "posts.restore": siteOperation("restore", { postId: resourceId }),
+    "media.list": siteOperation("", {
+      number: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      page_handle: { type: "string", minLength: 1, maxLength: 4096 },
+      search: { type: "string", minLength: 1, maxLength: 500 },
+      post_ID: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+      mime_type: { type: "string", minLength: 1, maxLength: 150 }
+    }, { ...mediaOptions, read: true, collection: true,
+      validateResult: value => Number.isSafeInteger(value?.found) && value.found >= 0 && Array.isArray(value.media) && value.media.every(mediaRecord) &&
+        (value.meta?.next_page == null || typeof value.meta.next_page === "string") }),
+    "media.get": siteOperation("", { mediaId: resourceId }, { ...mediaOptions, read: true }),
+    "media.update": siteOperation("", { mediaId: resourceId, ...mediaFields }, { ...mediaOptions, changesRequired: true }),
+    "media.delete": siteOperation("delete", {
+      mediaId: resourceId,
+      confirmDeletion: { type: "boolean", required: true, validator: value => value === true || "Confirm permanent media deletion." }
+    }, { ...mediaOptions, validateResult: value => mediaRecord(value) && value.status === "deleted" }),
+    "media.upload": {
+      scopes: ["media"],
+      request(input) {
+        const { siteId, filename, mimeType, contentBase64, ...metadata } = validateSchemaPayload({ schema: mediaUploadSchema, mode: "replace" }, input, { statusCode: 422 });
+        const bytes = Buffer.from(contentBase64, "base64");
+        if (!bytes.length || bytes.length > 5 * 1024 * 1024 || bytes.toString("base64") !== contentBase64) {
+          throw new ConnectorError("connector_input_invalid", "Supply canonical base64 for a nonempty file of at most 5 MiB.", { statusCode: 422 });
+        }
+        const body = new FormData();
+        body.append("media[0]", new Blob([bytes], { type: mimeType }), filename);
+        for (const [key, value] of Object.entries(metadata)) body.append(`attrs[0][${key}]`, String(value));
+        return { method: "POST", url: `https://public-api.wordpress.com/rest/v1.1/sites/${siteId}/media/new?context=edit`, body };
+      },
+      validateResult: value => Array.isArray(value?.media) && value.media.every(mediaRecord) &&
+        (value.media_errors == null || Array.isArray(value.media_errors) || typeof value.media_errors === "object")
+    },
+    "profile.read": {
+      ...jsonOperation("https://public-api.wordpress.com/rest/v1.1/me?fields=ID,username,display_name,token_scope,token_client_id,token_site_id", {},
+        (result) => Number.isSafeInteger(result?.ID) && result.ID > 0 && typeof result.username === "string" &&
+          typeof result.display_name === "string" && Number.isSafeInteger(result.token_client_id) && result.token_client_id > 0 &&
+          Number.isSafeInteger(result.token_site_id) && result.token_site_id >= 0 &&
+          Array.isArray(result.token_scope) && result.token_scope.every((scope) => typeof scope === "string" && scope.length > 0)),
+      scopes: ["users"]
+    },
+    "sites.list": {
+      ...jsonOperation("https://public-api.wordpress.com/rest/v1.1/me/sites", {
+        site_visibility: { type: "string", enum: ["all", "visible", "hidden"], defaultTo: "all" },
+        site_activity: { type: "string", enum: ["all", "active", "inactive"], defaultTo: "all" }
+      }, (result) => Array.isArray(result?.sites) && result.sites.every((site) => Number.isSafeInteger(site?.ID) && site.ID > 0 && typeof site.URL === "string")),
+      scopes: ["sites"]
+    },
+    "posts.list": {
+      scopes: ["posts"],
+      request(input) {
+        const { siteId, ...values } = validateSchemaPayload({ schema: postsSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL(`https://public-api.wordpress.com/rest/v1.1/sites/${siteId}/posts/`);
+        for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
+        return { method: "GET", url: url.href };
+      },
+      validateResult: (result) => Number.isSafeInteger(result?.found) && result.found >= 0 && Array.isArray(result.posts) &&
+        result.posts.every((post) => Number.isSafeInteger(post?.ID) && post.ID > 0 && typeof post.title === "string") &&
+        (result.meta?.next_page == null || typeof result.meta.next_page === "string")
+    }
+  }
+});
+export { wordpressComProvider };

package/src/server/wordpress-self-hosted.js

@@ -0,0 +1,134 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { wordpressSelfHostedDefinition } from "../shared/wordpress.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const baseUrl = (settings) => `${settings.siteUrl.replace(/\/+$/u, "")}/wp-json/wp/v2`;
+const id = { type: "integer", min: 1, max: Number.MAX_SAFE_INTEGER, required: true };
+const view = { type: "string", enum: ["view", "edit", "embed"], defaultTo: "view" };
+const status = { type: "string", enum: ["publish", "draft", "pending", "private"] };
+const contentRecord = (value) => Number.isSafeInteger(value?.id) && value.id > 0 && typeof value.title?.rendered === "string";
+const contentFields = {
+  title: { type: "string", maxLength: 10000, noTrim: true },
+  content: { type: "string", maxLength: 1000000, noTrim: true },
+  excerpt: { type: "string", maxLength: 100000, noTrim: true },
+  slug: { type: "string", minLength: 1, maxLength: 200 },
+  status,
+  featured_media: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+  comment_status: { type: "string", enum: ["open", "closed"] }
+};
+function wordpressOperation(resource, fields, method, validateResult, { write = false } = {}) {
+  const schema = createSchema(fields);
+  return { scopes: [], request(input, settings) {
+    const { id: resourceId, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const url = new URL(`${baseUrl(settings)}/${resource}${resourceId ? `/${resourceId}` : ""}`);
+    if (write) {
+      if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+      return { method, url: url.href, body: values };
+    }
+    for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
+    if (method === "DELETE" && !url.searchParams.has("force")) url.searchParams.set("force", "false");
+    return { method, url: url.href };
+  }, validateResult };
+}
+const contentOperations = Object.fromEntries(["posts", "pages"].flatMap((resource) => {
+  const fields = { ...contentFields, ...(resource === "pages" ? {
+    parent: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+    menu_order: { type: "integer", min: -2147483648, max: 2147483647 }
+  } : {}) };
+  return [
+    [`${resource}.get`, wordpressOperation(resource, { id, context: view }, "GET", contentRecord)],
+    [`${resource}.create`, wordpressOperation(resource, { ...fields,
+      title: { ...fields.title, required: true, minLength: 1 }, status: { ...status, defaultTo: "draft" }
+    }, "POST", contentRecord, { write: true })],
+    [`${resource}.update`, wordpressOperation(resource, { id, ...fields }, "POST", contentRecord, { write: true })],
+    [`${resource}.trash`, wordpressOperation(resource, { id }, "DELETE",
+      value => contentRecord(value) && value.status === "trash")]
+  ];
+}));
+const listFields = {
+  page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+  per_page: { type: "integer", min: 1, max: 100, defaultTo: 10 },
+  search: { type: "string", minLength: 1, maxLength: 500 }, context: view
+};
+const mediaRecord = (value) => contentRecord(value) && typeof value.source_url === "string";
+const userRecord = (value) => Number.isSafeInteger(value?.id) && value.id > 0 && typeof value.name === "string" &&
+  typeof value.slug === "string" && !Object.hasOwn(value, "password");
+const permanent = { type: "boolean", required: true, validator: value => value === true || "Explicitly confirm permanent deletion with force: true." };
+const mediaFields = {
+  title: contentFields.title,
+  caption: contentFields.excerpt,
+  description: contentFields.content,
+  alt_text: { type: "string", maxLength: 10000, noTrim: true },
+  post: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER }
+};
+const uploadSchema = createSchema({ ...mediaFields,
+  filename: { type: "string", required: true, minLength: 1, maxLength: 255,
+    validator: value => !/[\\/\p{Cc}"]/u.test(value) && ![".", ".."].includes(value) || "Use a filename without paths, quotes or control characters." },
+  mimeType: { type: "string", required: true, maxLength: 150, pattern: "^[a-zA-Z0-9.+-]+/[a-zA-Z0-9.+-]+$" },
+  contentBase64: { type: "string", required: true, minLength: 4, maxLength: 6990508, noTrim: true }
+});
+const userFields = {
+  name: { type: "string", maxLength: 250 }, first_name: { type: "string", maxLength: 250 },
+  last_name: { type: "string", maxLength: 250 }, nickname: { type: "string", maxLength: 250 },
+  description: { type: "string", maxLength: 10000, noTrim: true },
+  email: { type: "string", maxLength: 320, validator: value => /^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(value) || "Enter an email address." },
+  password: { type: "string", minLength: 1, maxLength: 4096, noTrim: true },
+  roles: { type: "array", items: { type: "string", minLength: 1, maxLength: 100, pattern: "^[a-zA-Z0-9_-]+$" },
+    validator: values => values.length >= 1 && values.length <= 10 && new Set(values).size === values.length || "Choose one to ten distinct WordPress roles." }
+};
+const wordpressSelfHostedProvider = Object.freeze({
+  ...wordpressSelfHostedDefinition,
+  apiOrigins: (settings) => [new URL(settings.siteUrl).origin],
+  apiKey: { headers: (password, settings) => ({ Authorization: `Basic ${Buffer.from(`${settings.username}:${password}`).toString("base64")}` }) },
+  checkOperation: "users.me",
+  operations: {
+    ...contentOperations,
+    "media.list": wordpressOperation("media", { ...listFields,
+      media_type: { type: "string", enum: ["image", "video", "text", "application", "audio"] }
+    }, "GET", value => Array.isArray(value) && value.every(mediaRecord)),
+    "media.get": wordpressOperation("media", { id, context: view }, "GET", mediaRecord),
+    "media.update": wordpressOperation("media", { id, ...mediaFields }, "POST", mediaRecord, { write: true }),
+    "media.delete": wordpressOperation("media", { id, force: permanent }, "DELETE",
+      value => value?.deleted === true && mediaRecord(value.previous)),
+    "media.upload": { scopes: [], request(input, settings) {
+      const { filename, mimeType, contentBase64, ...metadata } = validateSchemaPayload({ schema: uploadSchema, mode: "replace" }, input, { statusCode: 422 });
+      const bytes = Buffer.from(contentBase64, "base64");
+      if (!bytes.length || bytes.length > 5 * 1024 * 1024 || bytes.toString("base64") !== contentBase64) {
+        throw new ConnectorError("connector_input_invalid", "Supply canonical base64 for a nonempty file of at most 5 MiB.", { statusCode: 422 });
+      }
+      const body = new FormData();
+      body.append("file", new Blob([bytes], { type: mimeType }), filename);
+      for (const [name, value] of Object.entries(metadata)) body.append(name, String(value));
+      return { method: "POST", url: `${baseUrl(settings)}/media`, body };
+    }, validateResult: mediaRecord },
+    "users.list": wordpressOperation("users", listFields, "GET", value => Array.isArray(value) && value.every(userRecord)),
+    "users.get": wordpressOperation("users", { id, context: view }, "GET", userRecord),
+    "users.create": wordpressOperation("users", { ...userFields,
+      username: { type: "string", required: true, minLength: 1, maxLength: 60, pattern: "^[^:\\s]+$" },
+      email: { ...userFields.email, required: true }, password: { ...userFields.password, required: true },
+      roles: { ...userFields.roles, required: true }
+    }, "POST", userRecord, { write: true }),
+    "users.update": wordpressOperation("users", { id, ...userFields }, "POST", userRecord, { write: true }),
+    "users.delete": wordpressOperation("users", { id, force: permanent, reassign: id }, "DELETE",
+      value => value?.deleted === true && userRecord(value.previous)),
+    "pages.list": wordpressOperation("pages", {
+      page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+      per_page: { type: "integer", min: 1, max: 100, defaultTo: 10 },
+      search: { type: "string", minLength: 1, maxLength: 500 },
+      context: view, status: { ...status, defaultTo: "publish" }
+    }, "GET", value => Array.isArray(value) && value.every(contentRecord)),
+    "users.me": jsonOperation((settings) => `${baseUrl(settings)}/users/me`, {},
+      (result) => Number.isInteger(result?.id) && result.id > 0 && typeof result.name === "string" && typeof result.slug === "string"),
+    "posts.list": jsonOperation((settings) => `${baseUrl(settings)}/posts`, {
+      page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+      per_page: { type: "integer", min: 1, max: 100, defaultTo: 10 },
+      search: { type: "string", minLength: 1, maxLength: 500 },
+      status: { type: "string", enum: ["publish", "future", "draft", "pending", "private"], defaultTo: "publish" },
+      context: { type: "string", enum: ["view", "edit", "embed"], defaultTo: "view" }
+    }, (result) => Array.isArray(result) && result.every((post) => Number.isInteger(post?.id) && post.id > 0 && typeof post.title?.rendered === "string"))
+  }
+});
+
+export { wordpressSelfHostedProvider };

package/src/server/workday.js

@@ -0,0 +1,136 @@
+import { workdayDefinition, workdayRestEndpoint } from "../shared/workday.js";
+import { jsonOperation } from "./jsonOperation.js";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+
+function workersUrl(settings) {
+  const { host, prefix = "", tenant } = workdayRestEndpoint(settings.restApiEndpoint);
+  return `https://${host}${prefix}/api/staffing/v7/${tenant}/workers`;
+}
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const worker = (value) => object(value) && /^[a-f0-9]{32}$/u.test(value.id) && typeof value.descriptor === "string" &&
+  (value.workerId === undefined || typeof value.workerId === "string");
+const pageFields = {
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  offset: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER, defaultTo: 0 }
+};
+const organizationRecord = (value) => object(value) && typeof value.id === "string" && value.id.length > 0 &&
+  typeof value.descriptor === "string";
+const organizationPage = (value) => object(value) && !value.error && !value.errors && Number.isSafeInteger(value.total) && value.total >= 0 &&
+  Array.isArray(value.data) && value.data.length <= 100 && value.data.every(organizationRecord);
+function organizationRead(part) {
+  const schema = createSchema({
+    id: { type: "string", required: true, maxLength: 256, noTrim: true,
+      validator: value => /^([0-9a-f]{32}|Organization_Reference_ID=\S+)$/u.test(value) || "Use a Workday organization ID or Organization_Reference_ID=value." },
+    ...(part ? pageFields : {})
+  });
+  return {
+    scopes: [],
+    request(input, settings) {
+      const { id, ...query } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(`${workersUrl(settings).replace(/\/workers$/u, "/supervisoryOrganizations")}/${encodeURIComponent(id)}${part ? `/${part}` : ""}`);
+      for (const [key, value] of Object.entries(query)) url.searchParams.set(key, String(value));
+      return { method: "GET", url: url.href };
+    },
+    validateResult: part ? organizationPage : organizationRecord
+  };
+}
+const workdayId = { type: "string", minLength: 32, maxLength: 32,
+  validator: value => /^[a-f0-9]{32}$/u.test(value) || "Use the returned Workday ID." };
+const dateField = { type: "string", noTrim: true,
+  validator: value => /^\d{4}-\d{2}-\d{2}$/u.test(value) && Number.isFinite(Date.parse(value)) &&
+    new Date(value).toISOString().slice(0, 10) === value || "Use a valid YYYY-MM-DD date." };
+function absenceRead(kind) {
+  const schema = createSchema(kind === "statuses" ? {} : {
+    ...pageFields,
+    worker: { ...workdayId, required: true },
+    ...(kind === "balances" ? { category: workdayId, effective: dateField } : {
+      fromDate: dateField, toDate: dateField,
+      status: { type: "array", validator: values => values.length > 0 && values.length <= 20 || "Choose 1–20 statuses.", items: workdayId },
+      timeOffType: { type: "array", validator: values => values.length > 0 && values.length <= 100 || "Choose 1–100 time-off types.", items: workdayId }
+    })
+  });
+  return {
+    scopes: [],
+    request(input, settings) {
+      const { worker: workerId, ...query } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      if (query.fromDate && query.toDate && query.fromDate > query.toDate) {
+        throw new ConnectorError("connector_input_invalid", "The start date must not follow the end date.", { statusCode: 422 });
+      }
+      const { host, prefix = "", tenant } = workdayRestEndpoint(settings.restApiEndpoint);
+      const path = kind === "statuses" ? "values/timeOff/status/" : kind === "balances" ? "balances" : `workers/${workerId}/timeOffDetails`;
+      const url = new URL(`https://${host}${prefix}/api/absenceManagement/v5/${tenant}/${path}`);
+      if (kind === "balances") url.searchParams.set("worker", workerId);
+      for (const [key, value] of Object.entries(query)) {
+        for (const item of Array.isArray(value) ? value : [value]) url.searchParams.append(key, String(item));
+      }
+      return { method: "GET", url: url.href };
+    },
+    validateResult(value) {
+      return object(value) && !value.error && !value.errors && Number.isSafeInteger(value.total) && value.total >= 0 &&
+        Array.isArray(value.data) && value.data.length <= 100 && value.data.every(row =>
+          kind === "statuses" ? organizationRecord(row) : object(row) && Number.isFinite(row.quantity) && object(row.unit) &&
+            (kind === "balances" ? object(row.absencePlan) : typeof row.date === "string" && object(row.status)));
+    }
+  };
+}
+const reportSegment = { type: "string", required: true, minLength: 1, maxLength: 256, noTrim: true,
+  // eslint-disable-next-line no-control-regex -- Reject literal control characters in provider input.
+  validator: value => !/[\\/\s%?#\u0000-\u001f]/u.test(value) && value !== "." && value !== ".." || "Copy the report URL's owner/name segment without separators or escaping." };
+const reportSchema = createSchema({
+  owner: reportSegment, report: reportSegment,
+  prompts: { type: "array", validator: values => values.length <= 50 || "Use at most 50 report prompts.",
+    items: { type: "object", schema: createSchema({
+      name: { type: "string", required: true, minLength: 1, maxLength: 256,
+        validator: value => /^[A-Za-z_][A-Za-z0-9_.-]*(?:!WID)?$/u.test(value) && value.toLowerCase() !== "format" || "Use a report prompt XML alias, optionally ending !WID; format is fixed." },
+      value: { type: "string", required: true, maxLength: 4096, noTrim: true }
+    }) }
+  }
+});
+const workdayProvider = Object.freeze({
+  ...workdayDefinition,
+  // Workday's captured confidential registration issues a secret when PKCE is disabled.
+  oauthPkce: false,
+  oauth: (settings) => ({ issuer: new URL(settings.authorizationEndpoint).origin,
+    authorization_endpoint: settings.authorizationEndpoint, token_endpoint: settings.tokenEndpoint }),
+  apiOrigins: (settings) => [new URL(settings.restApiEndpoint).origin],
+  checkOperation: "workers.me",
+  operations: {
+    "reports.read": {
+      scopes: [],
+      request(input, settings) {
+        const { owner, report, prompts = [] } = validateSchemaPayload({ schema: reportSchema, mode: "replace" }, input, { statusCode: 422 });
+        const { host, tenant } = workdayRestEndpoint(settings.restApiEndpoint);
+        const url = new URL(`https://${host}/ccx/service/customreport2/${tenant}/${encodeURIComponent(owner)}/${encodeURIComponent(report)}`);
+        const names = new Set();
+        for (const { name, value } of prompts) {
+          if (names.has(name)) throw new ConnectorError("connector_input_invalid", "Supply each report prompt once; join multi-instance WIDs with !.", { statusCode: 422 });
+          names.add(name); url.searchParams.set(name, value);
+        }
+        url.searchParams.set("format", "json");
+        if (url.href.length > 16384) throw new ConnectorError("connector_input_invalid", "Use a smaller report prompt request.", { statusCode: 422 });
+        return { method: "GET", url: url.href };
+      },
+      validateResult: result => object(result) && !result.error && !result.errors && Array.isArray(result.Report_Entry) && result.Report_Entry.every(object)
+    },
+    "timeOff.balances": absenceRead("balances"),
+    "timeOff.details": absenceRead("details"),
+    "timeOff.statuses": absenceRead("statuses"),
+    "organizations.list": jsonOperation((settings) => workersUrl(settings).replace(/\/workers$/u, "/supervisoryOrganizations"), {
+      ...pageFields, includeInactive: { type: "boolean" }
+    }, organizationPage),
+    "organizations.get": organizationRead(""),
+    "organizations.members": organizationRead("members"),
+    "organizations.orgChart": organizationRead("orgChart"),
+    "workers.me": jsonOperation((settings) => `${workersUrl(settings)}/me`, {}, worker),
+    "workers.list": jsonOperation(workersUrl, {
+      limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      offset: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER, defaultTo: 0 },
+      search: { type: "string", minLength: 1, maxLength: 512, noTrim: true },
+      includeTerminatedWorkers: { type: "boolean" }, filterByOrgVisibility: { type: "boolean" }
+    }, (result) => object(result) && !result.error && !result.errors && Number.isSafeInteger(result.total) && result.total >= 0 &&
+      Array.isArray(result.data) && result.data.length <= 100 && result.data.every(worker))
+  }
+});
+export { workdayProvider };

package/src/server/x-twitter.js

@@ -0,0 +1,110 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { xTwitterDefinition } from "../shared/x-twitter.js";
+
+const validId = (value) => typeof value === "string" && /^[0-9]{1,19}$/u.test(value);
+const validUsername = (value) => typeof value === "string" && /^[A-Za-z0-9_]{1,15}$/u.test(value);
+const validCursor = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096 && !/[\p{Cc}]/u.test(value);
+const lookupSchema = createSchema({ username: { type: "string", required: true, noTrim: true,
+  validator: (value) => validUsername(value) || "Enter an X username without @, spaces or a URL." } });
+const postsSchema = createSchema({
+  userId: { type: "string", required: true, noTrim: true, validator: (value) => validId(value) || "Enter an X user ID as a string of 1–19 digits." },
+  maxResults: { type: "integer", min: 5, max: 100, defaultTo: 10 },
+  paginationToken: { type: "string", noTrim: true, validator: (value) => validCursor(value) || "Use the returned pagination token (up to 4096 characters)." }
+});
+
+const searchSchema = createSchema({
+  query: { type: "string", required: true, noTrim: true,
+    validator: (value) => value.trim().length > 0 && value.length <= 512 && !/[\p{Cc}]/u.test(value) || "Enter a search query of 1–512 characters without control characters." },
+  maxResults: { type: "integer", min: 10, max: 100, defaultTo: 10 },
+  nextToken: { type: "string", noTrim: true, validator: (value) => validCursor(value) || "Use the returned next token." }
+});
+
+const xTwitterProvider = Object.freeze({
+  ...xTwitterDefinition, apiOrigins: ["https://api.x.com"],
+  apiKey: { headers: (key) => {
+    if (!/^[\x21-\x7e]+$/u.test(key) || key.length > 8192) {
+      throw new ConnectorError("connector_binding_missing", "Use the X app-only token without spaces, control characters or a Bearer prefix.");
+    }
+    return { Authorization: `Bearer ${key}` };
+  } },
+  checkOperation: "users.lookup",
+  operations: {
+    "posts.searchRecent": {
+      scopes: [],
+      request(input) {
+        const values = validateSchemaPayload({ schema: searchSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL("https://api.x.com/2/tweets/search/recent");
+        url.searchParams.set("query", values.query);
+        url.searchParams.set("max_results", String(values.maxResults));
+        if (values.nextToken !== undefined) url.searchParams.set("next_token", values.nextToken);
+        url.searchParams.set("tweet.fields", "created_at,author_id,attachments,entities,public_metrics");
+        url.searchParams.set("expansions", "author_id,attachments.media_keys");
+        url.searchParams.set("user.fields", "name,username,profile_image_url");
+        url.searchParams.set("media.fields", "type,url,preview_image_url,alt_text");
+        return { method: "GET", url: url.href };
+      }
+    },
+    "users.lookup": {
+      scopes: [],
+      request(input) {
+        const { username } = validateSchemaPayload({ schema: lookupSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL(`https://api.x.com/2/users/by/username/${username}`);
+        url.searchParams.set("user.fields", "description,profile_image_url,public_metrics");
+        return { method: "GET", url: url.href };
+      }
+    },
+    "users.posts": {
+      scopes: [],
+      request(input) {
+        // Snowflake IDs exceed JS's safe integer range; reject numbers before the schema can coerce them.
+        if (typeof input?.userId !== "string") {
+          const error = new ConnectorError("connector_input_invalid", "Pass the X user ID as a string.", { statusCode: 422 });
+          error.fieldErrors = { userId: "Pass the X user ID as a string." };
+          throw error;
+        }
+        const values = validateSchemaPayload({ schema: postsSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL(`https://api.x.com/2/users/${values.userId}/tweets`);
+        url.searchParams.set("max_results", String(values.maxResults));
+        if (values.paginationToken !== undefined) url.searchParams.set("pagination_token", values.paginationToken);
+        return { method: "GET", url: url.href };
+      }
+    }
+  },
+  async exchange(address, options, { request }) {
+    let result;
+    try { result = await request(address, options); } catch (error) {
+      const status = Number(error?.status || error?.statusCode);
+      if (status === 402) throw new ConnectorError("connector_billing_required", "Check this X application's API credits and billing access.", { statusCode: 402 });
+      if (status === 404) throw new ConnectorError("connector_resource_not_found", "The X resource was not found or is not available.", { statusCode: 404 });
+      throw error;
+    }
+    if (Array.isArray(result?.errors) && result.errors.length) {
+      if (!result.data && result.errors.every((error) => [
+        "https://api.x.com/2/problems/resource-not-found", "https://api.twitter.com/2/problems/resource-not-found"
+      ].includes(error?.type))) {
+        throw new ConnectorError("connector_resource_not_found", "The X resource was not found or is not available.", { statusCode: 404 });
+      }
+      throw new ConnectorError("connector_response_incomplete", "X could not return the complete requested data.", { statusCode: 502 });
+    }
+    const url = new URL(address);
+    let valid = result && typeof result === "object" && !Array.isArray(result) &&
+      (result.errors === undefined || Array.isArray(result.errors));
+    if (url.pathname.startsWith("/2/users/by/username/")) {
+      valid &&= validId(result.data?.id) && validUsername(result.data?.username) && typeof result.data.name === "string" &&
+        result.data.username.toLowerCase() === url.pathname.split("/").at(-1).toLowerCase();
+    } else {
+      const count = result?.meta?.result_count;
+      valid &&= Number.isSafeInteger(count) && count >= 0 && count <= Number(url.searchParams.get("max_results")) &&
+        (result.data === undefined ? count === 0 : Array.isArray(result.data) && result.data.length === count &&
+          result.data.every((post) => validId(post?.id) && typeof post.text === "string")) &&
+        ["next_token", "previous_token"].every((field) => result.meta[field] === undefined || validCursor(result.meta[field])) &&
+        ["newest_id", "oldest_id"].every((field) => result.meta[field] === undefined || validId(result.meta[field]));
+    }
+    if (!valid) throw new ConnectorError("connector_response_invalid", "X returned unexpected data.", { statusCode: 502 });
+    return result;
+  }
+});
+
+export { xTwitterProvider };