@pipeline-builder/api-core 3.4.113 → 3.4.114

package/lib/helpers/org-hierarchy-http.d.ts

@@ -47,6 +47,19 @@ export declare function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOp
  * `string[]`.
  */
 export declare function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined>;
+/**
+ * Batch-resolve org id → display NAME via platform's `POST /organization/names`.
+ * Returns a lowercased `{ [orgId]: name }` map — ids the platform doesn't know
+ * are simply absent (caller falls back to the raw id).
+ *
+ * Best-effort by design: a non-2xx response (e.g. the caller isn't a service
+ * principal) or a malformed body yields `{}`, and it throws ONLY on a transport
+ * failure (connection/timeout) — matching the fail-soft policy of the other
+ * lookups here so a name-enrichment read never fails the caller's request. The
+ * response is validated entry-by-entry (only string→string pairs survive), so a
+ * malformed payload can't smuggle a non-string into the returned map.
+ */
+export declare function fetchOrgNames(orgIds: string[], opts: OrgHierarchyHttpOptions): Promise<Record<string, string>>;
 /**
  * Check whether `userId` is an ACTIVE member of `orgId` via platform's
  * `GET /organization/:id/members/:userId/exists`. Returns the boolean the

package/lib/helpers/org-hierarchy-http.js

@@ -17,7 +17,7 @@
  * level, degrade-to-self vs. return-undefined). A non-2xx response is treated
  * as "no data" (returns undefined), matching what the callers previously did.
  */
-import { getServiceAuthHeader } from '../middleware/auth.js';
+import { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';
 import { InternalHttpClient } from '../services/http-client.js';
 function buildRequest(orgId, suffix, opts) {
     const client = new InternalHttpClient(opts.service);
@@ -74,6 +74,45 @@ export async function fetchOrgDescendants(orgId, opts) {
     // Only meaningful when the (validated) subtree is larger than the org itself.
     return orgIds.length > 1 ? orgIds : undefined;
 }
+/**
+ * Batch-resolve org id → display NAME via platform's `POST /organization/names`.
+ * Returns a lowercased `{ [orgId]: name }` map — ids the platform doesn't know
+ * are simply absent (caller falls back to the raw id).
+ *
+ * Best-effort by design: a non-2xx response (e.g. the caller isn't a service
+ * principal) or a malformed body yields `{}`, and it throws ONLY on a transport
+ * failure (connection/timeout) — matching the fail-soft policy of the other
+ * lookups here so a name-enrichment read never fails the caller's request. The
+ * response is validated entry-by-entry (only string→string pairs survive), so a
+ * malformed payload can't smuggle a non-string into the returned map.
+ */
+export async function fetchOrgNames(orgIds, opts) {
+    if (orgIds.length === 0)
+        return {};
+    const client = new InternalHttpClient(opts.service);
+    const headers = {
+        Authorization: getServiceAuthHeader({
+            serviceName: opts.serviceName,
+            // A cross-org registry read, not a tenant-scoped op — default to the system
+            // org context when the caller doesn't pin one.
+            orgId: opts.authOrgId ?? SYSTEM_ORG_ID,
+            role: opts.role ?? 'member',
+        }),
+        ...opts.headers,
+    };
+    const res = await client.post('/organization/names', { orgIds }, { headers, timeout: opts.timeout });
+    if (res.statusCode >= 400)
+        return {};
+    const names = res.body?.data?.names;
+    if (!names || typeof names !== 'object')
+        return {};
+    const out = {};
+    for (const [id, name] of Object.entries(names)) {
+        if (typeof name === 'string')
+            out[id.toLowerCase()] = name;
+    }
+    return out;
+}
 /**
  * Check whether `userId` is an ACTIVE member of `orgId` via platform's
  * `GET /organization/:id/members/:userId/exists`. Returns the boolean the
@@ -102,4 +141,4 @@ export async function fetchOrgMembership(orgId, userId, opts) {
     const isMember = res.body?.data?.isMember;
     return typeof isMember === 'boolean' ? isMember : undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n  /**\n   * When true, a non-2xx response THROWS instead of resolving to `undefined`.\n   * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the\n   * message/reporting root-resolution callers rely on). A caller for whom a\n   * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a\n   * team org as parent-less would silently skip inherited blocking rules — sets\n   * this so it can distinguish \"root org\" (`undefined`) from \"lookup failed\".\n   */\n  throwOnHttpError?: boolean;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx\n * response resolves to `undefined` by default, or THROWS when\n * `throwOnHttpError` is set. Always throws on a transport failure\n * (connection/timeout) so the caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) {\n    if (opts.throwOnHttpError) {\n      throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);\n    }\n    return undefined;\n  }\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n\n/**\n * Check whether `userId` is an ACTIVE member of `orgId` via platform's\n * `GET /organization/:id/members/:userId/exists`. Returns the boolean the\n * platform reports.\n *\n * Returns `undefined` (— \"couldn't determine\") on a non-2xx response, and\n * throws only on a transport failure (connection/timeout) — so the caller\n * distinguishes a definitive not-a-member (`false`) from an indeterminate\n * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`\n * differs from the parent/descendants shape, so this builds its own request.\n */\nexport async function fetchOrgMembership(\n  orgId: string,\n  userId: string,\n  opts: OrgHierarchyHttpOptions,\n): Promise<boolean | undefined> {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}/exists`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  const res = await client.get<{ data?: { isMember?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const isMember = res.body?.data?.isMember;\n  return typeof isMember === 'boolean' ? isMember : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n  /**\n   * When true, a non-2xx response THROWS instead of resolving to `undefined`.\n   * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the\n   * message/reporting root-resolution callers rely on). A caller for whom a\n   * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a\n   * team org as parent-less would silently skip inherited blocking rules — sets\n   * this so it can distinguish \"root org\" (`undefined`) from \"lookup failed\".\n   */\n  throwOnHttpError?: boolean;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx\n * response resolves to `undefined` by default, or THROWS when\n * `throwOnHttpError` is set. Always throws on a transport failure\n * (connection/timeout) so the caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) {\n    if (opts.throwOnHttpError) {\n      throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);\n    }\n    return undefined;\n  }\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n\n/**\n * Batch-resolve org id → display NAME via platform's `POST /organization/names`.\n * Returns a lowercased `{ [orgId]: name }` map — ids the platform doesn't know\n * are simply absent (caller falls back to the raw id).\n *\n * Best-effort by design: a non-2xx response (e.g. the caller isn't a service\n * principal) or a malformed body yields `{}`, and it throws ONLY on a transport\n * failure (connection/timeout) — matching the fail-soft policy of the other\n * lookups here so a name-enrichment read never fails the caller's request. The\n * response is validated entry-by-entry (only string→string pairs survive), so a\n * malformed payload can't smuggle a non-string into the returned map.\n */\nexport async function fetchOrgNames(\n  orgIds: string[],\n  opts: OrgHierarchyHttpOptions,\n): Promise<Record<string, string>> {\n  if (orgIds.length === 0) return {};\n  const client = new InternalHttpClient(opts.service);\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      // A cross-org registry read, not a tenant-scoped op — default to the system\n      // org context when the caller doesn't pin one.\n      orgId: opts.authOrgId ?? SYSTEM_ORG_ID,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  const res = await client.post<{ data?: { names?: unknown } }>(\n    '/organization/names',\n    { orgIds },\n    { headers, timeout: opts.timeout },\n  );\n  if (res.statusCode >= 400) return {};\n  const names = res.body?.data?.names;\n  if (!names || typeof names !== 'object') return {};\n  const out: Record<string, string> = {};\n  for (const [id, name] of Object.entries(names as Record<string, unknown>)) {\n    if (typeof name === 'string') out[id.toLowerCase()] = name;\n  }\n  return out;\n}\n\n/**\n * Check whether `userId` is an ACTIVE member of `orgId` via platform's\n * `GET /organization/:id/members/:userId/exists`. Returns the boolean the\n * platform reports.\n *\n * Returns `undefined` (— \"couldn't determine\") on a non-2xx response, and\n * throws only on a transport failure (connection/timeout) — so the caller\n * distinguishes a definitive not-a-member (`false`) from an indeterminate\n * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`\n * differs from the parent/descendants shape, so this builds its own request.\n */\nexport async function fetchOrgMembership(\n  orgId: string,\n  userId: string,\n  opts: OrgHierarchyHttpOptions,\n): Promise<boolean | undefined> {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}/exists`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  const res = await client.get<{ data?: { isMember?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const isMember = res.body?.data?.isMember;\n  return typeof isMember === 'boolean' ? isMember : undefined;\n}\n"]}

package/lib/validation/message-schemas.d.ts

@@ -92,10 +92,29 @@ export declare const MESSAGE_MAX_ATTACHMENTS = 5;
 export declare const MESSAGE_ATTACHMENT_MAX_MB: number;
 export declare const MESSAGE_ATTACHMENT_MAX_BYTES: number;
 /**
- * Allow-list of attachment MIME types — common images + documents. Deliberately
- * excludes executables/scripts/HTML/SVG (stored-XSS / drive-by). Extend here.
+ * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.
+ * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).
+ * zip is a download container (doesn't render in-browser); yaml/json are plain
+ * text — none carry the drive-by risk of the excluded types. Extend here.
  */
 export declare const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string>;
+/**
+ * Safe filename extensions. Browsers frequently send `application/octet-stream`
+ * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no
+ * reliable registered MIME type, so the MIME allow-list alone rejects them. These
+ * extensions are accepted as a fallback ONLY when the reported MIME is that
+ * generic type (see isAllowedAttachmentType) — so a known render/execute MIME
+ * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still
+ * excludes .html/.svg/.js/.exe/… (never listed here).
+ */
+export declare const MESSAGE_ATTACHMENT_ALLOWED_EXT: ReadonlySet<string>;
+/**
+ * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the
+ * browser reports the generic `application/octet-stream` (unknown binary) — by a
+ * safe filename extension. octet-stream is served as a download (never rendered),
+ * so the extension fallback can't turn into a stored-XSS vector.
+ */
+export declare function isAllowedAttachmentType(mimetype: string, filename: string): boolean;
 /** Attachment metadata DTO returned to clients (never exposes the storage key). */
 export interface MessageAttachmentDTO {
     id: string;

package/lib/validation/message-schemas.js

@@ -61,18 +61,60 @@ export const MESSAGE_MAX_ATTACHMENTS = 5;
 export const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);
 export const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;
 /**
- * Allow-list of attachment MIME types — common images + documents. Deliberately
- * excludes executables/scripts/HTML/SVG (stored-XSS / drive-by). Extend here.
+ * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.
+ * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).
+ * zip is a download container (doesn't render in-browser); yaml/json are plain
+ * text — none carry the drive-by risk of the excluded types. Extend here.
  */
 export const MESSAGE_ATTACHMENT_ALLOWED_MIME = new Set([
     'image/png', 'image/jpeg', 'image/gif', 'image/webp',
-    'application/pdf', 'text/plain', 'text/csv', 'application/json',
+    'application/pdf', 'text/plain', 'text/csv',
     'application/msword',
     'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
     'application/vnd.ms-excel',
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
     'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    // Archives (zip / gz / tar / tar.gz) — browsers report these variously by OS;
+    // cover the common variants. They download rather than render in-browser.
+    'application/zip', 'application/x-zip-compressed',
+    'application/gzip', 'application/x-gzip',
+    'application/x-tar', 'application/tar',
+    'application/x-compressed-tar',
+    // json (browsers may send application/json or text/json).
+    'application/json', 'text/json',
+    // yaml/yml — no single registered type; cover the common variants.
+    'application/x-yaml', 'application/yaml', 'text/yaml', 'text/x-yaml',
 ]);
+/**
+ * Safe filename extensions. Browsers frequently send `application/octet-stream`
+ * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no
+ * reliable registered MIME type, so the MIME allow-list alone rejects them. These
+ * extensions are accepted as a fallback ONLY when the reported MIME is that
+ * generic type (see isAllowedAttachmentType) — so a known render/execute MIME
+ * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still
+ * excludes .html/.svg/.js/.exe/… (never listed here).
+ */
+export const MESSAGE_ATTACHMENT_ALLOWED_EXT = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp',
+    '.pdf', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.gz', '.tgz', '.tar', '.json', '.yaml', '.yml',
+]);
+/**
+ * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the
+ * browser reports the generic `application/octet-stream` (unknown binary) — by a
+ * safe filename extension. octet-stream is served as a download (never rendered),
+ * so the extension fallback can't turn into a stored-XSS vector.
+ */
+export function isAllowedAttachmentType(mimetype, filename) {
+    if (MESSAGE_ATTACHMENT_ALLOWED_MIME.has(mimetype))
+        return true;
+    if (mimetype !== 'application/octet-stream')
+        return false;
+    const dot = (filename || '').lastIndexOf('.');
+    if (dot < 0)
+        return false;
+    return MESSAGE_ATTACHMENT_ALLOWED_EXT.has(filename.slice(dot).toLowerCase());
+}
 /**
  * Attachment ids to link to a message. Each is the id returned by a prior
  * POST /messages/attachments upload; the create route links only ids that belong
@@ -111,4 +153,4 @@ export const MessageReplySchema = z.object({
 export const MessageEditSchema = z.object({
     content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-schemas.js","sourceRoot":"","sources":["../../src/validation/message-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\nimport { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';\n\n/**\n * Message type schema\n */\nexport const MessageTypeSchema = z.enum(['announcement', 'conversation']);\n\n/**\n * Message priority schema\n */\nexport const MessagePrioritySchema = z.enum(['normal', 'high', 'urgent']);\n\n/**\n * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we\n * can add new channels (support, help, billing, …) without a schema\n * migration. Constrained to a-z/0-9/dash/underscore for URL safety and\n * to keep filter conditions trivially indexable.\n */\nexport const MessageChannelSchema = z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/);\n\n/**\n * Message filter schema for query parameters.\n *\n * Convention for `threadId`:\n * - Omitted (undefined): no filter applied — returns messages regardless of thread.\n * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`\n *   by the route layer / query builder). The string sentinel `'root'` is the\n *   wire form, since URL query params can't carry a true `null`.\n * - A UUID: filter for messages in that specific thread.\n *\n * `isRead` is honored by `buildMessageConditions` in pipeline-data via a\n * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting\n * org (the function form, not the `?` operator, to avoid param-binding clashes).\n */\nexport const MessageFilterSchema = BaseFilterSchema.extend({\n  threadId: z.union([z.string().uuid(), z.literal('root'), z.null()]).optional(),\n  recipientOrgId: z.string().min(1).optional(),\n  messageType: MessageTypeSchema.optional(),\n  isRead: BooleanQuerySchema.optional(),\n  priority: MessagePrioritySchema.optional(),\n  channel: MessageChannelSchema.optional(),\n  // Free-text inbox search over subject/content. Bounded so a pathological term\n  // can't blow up the LIKE; the query builder escapes wildcards + ignores blanks.\n  search: z.string().trim().min(1).max(200).optional(),\n});\n\n/**\n * Upper bounds on free-text message fields. Without these an unbounded\n * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to\n * every org. `subject` matches the `varchar(500)` DB column so we reject rather\n * than silently truncate; `content` is a `text` column with no DB bound, so we\n * cap it at a sane 32 KiB at the app layer.\n */\nexport const MESSAGE_SUBJECT_MAX = 500;\nexport const MESSAGE_CONTENT_MAX = 32768;\n\n/** Max attachments linkable to a single message/reply. */\nexport const MESSAGE_MAX_ATTACHMENTS = 5;\n\n/**\n * Max attachment size (MiB) — env-overridable. The upload route enforces this\n * (multer `fileSize`); kept here so the bound lives with the other message\n * limits rather than only inline in the route.\n */\nexport const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);\nexport const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;\n\n/**\n * Allow-list of attachment MIME types — common images + documents. Deliberately\n * excludes executables/scripts/HTML/SVG (stored-XSS / drive-by). Extend here.\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string> = new Set([\n  'image/png', 'image/jpeg', 'image/gif', 'image/webp',\n  'application/pdf', 'text/plain', 'text/csv', 'application/json',\n  'application/msword',\n  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  'application/vnd.ms-excel',\n  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n]);\n\n/** Attachment metadata DTO returned to clients (never exposes the storage key). */\nexport interface MessageAttachmentDTO {\n  id: string;\n  filename: string;\n  contentType: string;\n  sizeBytes: number;\n}\n\n/**\n * Attachment ids to link to a message. Each is the id returned by a prior\n * POST /messages/attachments upload; the create route links only ids that belong\n * to the caller (own org + uploader) and are still unattached.\n */\nconst AttachmentIdsSchema = z.array(z.string().uuid()).max(MESSAGE_MAX_ATTACHMENTS).optional();\n\n/**\n * Message creation schema\n */\nexport const MessageCreateSchema = z.object({\n  recipientOrgId: z.string().min(1, 'Recipient organization ID is required'),\n  // Optional per-user targeting WITHIN recipientOrgId. When set, only this user\n  // sees the conversation (enforced in buildMessageConditions). Conversation-only\n  // and requires a concrete recipient org — the route rejects it on announcements\n  // and '*' broadcasts. Bounded to the recipient_user_id column width.\n  recipientUserId: z.string().min(1).max(255).optional(),\n  messageType: MessageTypeSchema.optional().default('conversation'),\n  channel: MessageChannelSchema.optional(),\n  subject: z.string().min(1, 'Subject is required').max(MESSAGE_SUBJECT_MAX, `Subject must be at most ${MESSAGE_SUBJECT_MAX} characters`),\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  priority: MessagePrioritySchema.optional().default('normal'),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Message reply schema\n */\nexport const MessageReplySchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Edit an already-sent message's CONTENT (author-only, enforced server-side).\n * Only the body is editable — subject/recipient/type/attachments are immutable\n * after send (changing them would rewrite the conversation's routing/meaning).\n */\nexport const MessageEditSchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-schemas.js","sourceRoot":"","sources":["../../src/validation/message-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\nimport { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';\n\n/**\n * Message type schema\n */\nexport const MessageTypeSchema = z.enum(['announcement', 'conversation']);\n\n/**\n * Message priority schema\n */\nexport const MessagePrioritySchema = z.enum(['normal', 'high', 'urgent']);\n\n/**\n * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we\n * can add new channels (support, help, billing, …) without a schema\n * migration. Constrained to a-z/0-9/dash/underscore for URL safety and\n * to keep filter conditions trivially indexable.\n */\nexport const MessageChannelSchema = z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/);\n\n/**\n * Message filter schema for query parameters.\n *\n * Convention for `threadId`:\n * - Omitted (undefined): no filter applied — returns messages regardless of thread.\n * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`\n *   by the route layer / query builder). The string sentinel `'root'` is the\n *   wire form, since URL query params can't carry a true `null`.\n * - A UUID: filter for messages in that specific thread.\n *\n * `isRead` is honored by `buildMessageConditions` in pipeline-data via a\n * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting\n * org (the function form, not the `?` operator, to avoid param-binding clashes).\n */\nexport const MessageFilterSchema = BaseFilterSchema.extend({\n  threadId: z.union([z.string().uuid(), z.literal('root'), z.null()]).optional(),\n  recipientOrgId: z.string().min(1).optional(),\n  messageType: MessageTypeSchema.optional(),\n  isRead: BooleanQuerySchema.optional(),\n  priority: MessagePrioritySchema.optional(),\n  channel: MessageChannelSchema.optional(),\n  // Free-text inbox search over subject/content. Bounded so a pathological term\n  // can't blow up the LIKE; the query builder escapes wildcards + ignores blanks.\n  search: z.string().trim().min(1).max(200).optional(),\n});\n\n/**\n * Upper bounds on free-text message fields. Without these an unbounded\n * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to\n * every org. `subject` matches the `varchar(500)` DB column so we reject rather\n * than silently truncate; `content` is a `text` column with no DB bound, so we\n * cap it at a sane 32 KiB at the app layer.\n */\nexport const MESSAGE_SUBJECT_MAX = 500;\nexport const MESSAGE_CONTENT_MAX = 32768;\n\n/** Max attachments linkable to a single message/reply. */\nexport const MESSAGE_MAX_ATTACHMENTS = 5;\n\n/**\n * Max attachment size (MiB) — env-overridable. The upload route enforces this\n * (multer `fileSize`); kept here so the bound lives with the other message\n * limits rather than only inline in the route.\n */\nexport const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);\nexport const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;\n\n/**\n * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.\n * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).\n * zip is a download container (doesn't render in-browser); yaml/json are plain\n * text — none carry the drive-by risk of the excluded types. Extend here.\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string> = new Set([\n  'image/png', 'image/jpeg', 'image/gif', 'image/webp',\n  'application/pdf', 'text/plain', 'text/csv',\n  'application/msword',\n  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  'application/vnd.ms-excel',\n  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n  // Archives (zip / gz / tar / tar.gz) — browsers report these variously by OS;\n  // cover the common variants. They download rather than render in-browser.\n  'application/zip', 'application/x-zip-compressed',\n  'application/gzip', 'application/x-gzip',\n  'application/x-tar', 'application/tar',\n  'application/x-compressed-tar',\n  // json (browsers may send application/json or text/json).\n  'application/json', 'text/json',\n  // yaml/yml — no single registered type; cover the common variants.\n  'application/x-yaml', 'application/yaml', 'text/yaml', 'text/x-yaml',\n]);\n\n/**\n * Safe filename extensions. Browsers frequently send `application/octet-stream`\n * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no\n * reliable registered MIME type, so the MIME allow-list alone rejects them. These\n * extensions are accepted as a fallback ONLY when the reported MIME is that\n * generic type (see isAllowedAttachmentType) — so a known render/execute MIME\n * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still\n * excludes .html/.svg/.js/.exe/… (never listed here).\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_EXT: ReadonlySet<string> = new Set([\n  '.png', '.jpg', '.jpeg', '.gif', '.webp',\n  '.pdf', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',\n  '.zip', '.gz', '.tgz', '.tar', '.json', '.yaml', '.yml',\n]);\n\n/**\n * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the\n * browser reports the generic `application/octet-stream` (unknown binary) — by a\n * safe filename extension. octet-stream is served as a download (never rendered),\n * so the extension fallback can't turn into a stored-XSS vector.\n */\nexport function isAllowedAttachmentType(mimetype: string, filename: string): boolean {\n  if (MESSAGE_ATTACHMENT_ALLOWED_MIME.has(mimetype)) return true;\n  if (mimetype !== 'application/octet-stream') return false;\n  const dot = (filename || '').lastIndexOf('.');\n  if (dot < 0) return false;\n  return MESSAGE_ATTACHMENT_ALLOWED_EXT.has(filename.slice(dot).toLowerCase());\n}\n\n/** Attachment metadata DTO returned to clients (never exposes the storage key). */\nexport interface MessageAttachmentDTO {\n  id: string;\n  filename: string;\n  contentType: string;\n  sizeBytes: number;\n}\n\n/**\n * Attachment ids to link to a message. Each is the id returned by a prior\n * POST /messages/attachments upload; the create route links only ids that belong\n * to the caller (own org + uploader) and are still unattached.\n */\nconst AttachmentIdsSchema = z.array(z.string().uuid()).max(MESSAGE_MAX_ATTACHMENTS).optional();\n\n/**\n * Message creation schema\n */\nexport const MessageCreateSchema = z.object({\n  recipientOrgId: z.string().min(1, 'Recipient organization ID is required'),\n  // Optional per-user targeting WITHIN recipientOrgId. When set, only this user\n  // sees the conversation (enforced in buildMessageConditions). Conversation-only\n  // and requires a concrete recipient org — the route rejects it on announcements\n  // and '*' broadcasts. Bounded to the recipient_user_id column width.\n  recipientUserId: z.string().min(1).max(255).optional(),\n  messageType: MessageTypeSchema.optional().default('conversation'),\n  channel: MessageChannelSchema.optional(),\n  subject: z.string().min(1, 'Subject is required').max(MESSAGE_SUBJECT_MAX, `Subject must be at most ${MESSAGE_SUBJECT_MAX} characters`),\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  priority: MessagePrioritySchema.optional().default('normal'),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Message reply schema\n */\nexport const MessageReplySchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Edit an already-sent message's CONTENT (author-only, enforced server-side).\n * Only the body is editable — subject/recipient/type/attachments are immutable\n * after send (changing them would rewrite the conversation's routing/meaning).\n */\nexport const MessageEditSchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n});\n"]}

package/package.json

@@ -87,7 +87,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.113",
+  "version": "3.4.114",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },