@credal/actions 0.2.222 → 0.2.224

package/dist/actions/providers/microsoft/readSharepointContent.js

@@ -0,0 +1,157 @@
+import mammoth from "mammoth";
+import officeParser from "officeparser";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { ApiError, axiosClient } from "../../util/axiosClient.js";
+import { extractTextFromPdf } from "../../../utils/pdf.js";
+import { parseWorkbookBufferToPlainText } from "../../../utils/google.js";
+import { MICROSOFT_GRAPH_API_URL } from "./utils.js";
+import { MISSING_SITES_SCOPE_MESSAGE, resolveItemFromUrl } from "./sharepointUtils.js";
+const DEFAULT_FILE_SIZE_LIMIT_MB = 50;
+const TEXT_MIME_TYPES = new Set([
+    "text/plain",
+    "text/html",
+    "text/csv",
+    "text/tab-separated-values",
+    "application/rtf",
+    "application/json",
+]);
+function stripHtml(html) {
+    return html
+        .replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&amp;/gi, "&")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        .replace(/[ \t]+/g, " ")
+        .replace(/\s*\n\s*/g, "\n")
+        .trim();
+}
+function buildResult(name, url, content, charLimit) {
+    const originalLength = content.length;
+    let finalContent = content.trim();
+    if (charLimit && charLimit > 0 && finalContent.length > charLimit) {
+        finalContent = `${finalContent.slice(0, charLimit)}\n\n[Content truncated to ${charLimit} characters]`;
+    }
+    return {
+        success: true,
+        results: [{ name, url, contents: { content: finalContent, fileName: name, fileLength: originalLength } }],
+    };
+}
+async function convertFileBuffer(mimeType, buffer, charLimit) {
+    if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" ||
+        mimeType === "application/msword") {
+        const result = await mammoth.extractRawText({ buffer });
+        return result.value ?? "";
+    }
+    if (mimeType === "application/pdf") {
+        return await extractTextFromPdf(buffer);
+    }
+    if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" ||
+        mimeType === "application/vnd.ms-excel") {
+        return parseWorkbookBufferToPlainText(buffer, charLimit);
+    }
+    if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation") {
+        return await officeParser.parseOfficeAsync(buffer);
+    }
+    if (TEXT_MIME_TYPES.has(mimeType) || mimeType.startsWith("text/")) {
+        return buffer.toString("utf-8");
+    }
+    throw new Error(`Unsupported file type: ${mimeType}`);
+}
+async function readFileContent(file, headers, charLimit, fileSizeLimit) {
+    const maxMegabytes = fileSizeLimit && fileSizeLimit > 0 ? fileSizeLimit : DEFAULT_FILE_SIZE_LIMIT_MB;
+    const maxFileSize = maxMegabytes * 1024 * 1024;
+    if (file.sizeBytes !== undefined && file.sizeBytes > maxFileSize) {
+        const actualMegabytes = (file.sizeBytes / (1024 * 1024)).toFixed(1);
+        return { success: false, error: `File too large: ${actualMegabytes}MB exceeds the ${maxMegabytes}MB limit` };
+    }
+    const downloadResponse = await axiosClient.get(`${MICROSOFT_GRAPH_API_URL}/drives/${file.driveId}/items/${file.itemId}/content`, { headers, responseType: "arraybuffer" });
+    const buffer = Buffer.from(downloadResponse.data);
+    const content = await convertFileBuffer(file.mimeType ?? "", buffer, charLimit);
+    return buildResult(file.name ?? "", file.webUrl ?? "", content, charLimit);
+}
+async function readPageContent(page, headers, charLimit) {
+    if (!page.pageId) {
+        return { success: false, error: "Could not identify the site page from the URL" };
+    }
+    try {
+        const response = await axiosClient.get(`${MICROSOFT_GRAPH_API_URL}/sites/${page.siteId}/pages/${page.pageId}/microsoft.graph.sitePage/webparts`, { headers });
+        const webparts = response.data.value ?? [];
+        const content = webparts
+            .map(webpart => (webpart.innerHtml ? stripHtml(webpart.innerHtml) : ""))
+            .filter(Boolean)
+            .join("\n\n");
+        return buildResult(page.name ?? "", page.webUrl ?? "", content, charLimit);
+    }
+    catch (error) {
+        if (error instanceof ApiError && (error.status === 401 || error.status === 403)) {
+            return { success: false, error: MISSING_SITES_SCOPE_MESSAGE };
+        }
+        throw error;
+    }
+}
+/**
+ * Resolve the target document from either a driveItem reference or a URL. The driveItem
+ * takes precedence over url when both are provided (it is an exact round-trip token; a
+ * url would be re-resolved and could name a different item).
+ */
+async function resolveTargetItem(authToken, params, headers) {
+    const { url, driveItem } = params;
+    if (driveItem) {
+        const { driveId, itemId } = driveItem;
+        const metadataResponse = await axiosClient.get(`${MICROSOFT_GRAPH_API_URL}/drives/${driveId}/items/${itemId}`, {
+            headers,
+        });
+        const item = metadataResponse.data;
+        return {
+            itemType: item.folder ? "folder" : "file",
+            driveId,
+            itemId,
+            name: item.name,
+            webUrl: item.webUrl,
+            mimeType: item.file?.mimeType,
+            sizeBytes: item.size,
+        };
+    }
+    return resolveItemFromUrl(authToken, url);
+}
+const readSharepointContent = async ({ params, authParams, }) => {
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    const { url, driveItem, charLimit, fileSizeLimit } = params;
+    if (charLimit != null && (!Number.isFinite(charLimit) || charLimit <= 0)) {
+        return { success: false, error: "charLimit must be a positive number" };
+    }
+    if (fileSizeLimit != null && (!Number.isFinite(fileSizeLimit) || fileSizeLimit <= 0)) {
+        return { success: false, error: "fileSizeLimit must be a positive number" };
+    }
+    if (!url && !driveItem) {
+        return { success: false, error: "Either url or driveItem must be provided" };
+    }
+    const headers = { Authorization: `Bearer ${authParams.authToken}` };
+    try {
+        const resolved = await resolveTargetItem(authParams.authToken, { url, driveItem }, headers);
+        if (resolved.itemType === "folder" || resolved.itemType === "site") {
+            return {
+                success: false,
+                error: `The URL points to a ${resolved.itemType}, not a document. Use listSharepointFolder to enumerate it and read files individually.`,
+            };
+        }
+        if (resolved.itemType === "page") {
+            return await readPageContent(resolved, headers, charLimit);
+        }
+        return await readFileContent(resolved, headers, charLimit, fileSizeLimit);
+    }
+    catch (error) {
+        console.error("Error reading SharePoint content", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+};
+export default readSharepointContent;

package/dist/actions/providers/microsoft/searchSharepoint.d.ts

@@ -0,0 +1,3 @@
+import type { microsoftSearchSharepointFunction } from "../../autogen/types.js";
+declare const searchSharepoint: microsoftSearchSharepointFunction;
+export default searchSharepoint;

package/dist/actions/providers/microsoft/searchSharepoint.js

@@ -0,0 +1,147 @@
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { axiosClient } from "../../util/axiosClient.js";
+import { MICROSOFT_GRAPH_API_URL } from "./utils.js";
+import { MISSING_SITES_SCOPE_MESSAGE, isSiteScopeError, resolveItemFromUrl } from "./sharepointUtils.js";
+const DEFAULT_LIMIT = 25;
+const SEARCH_PAGE_SIZE = 100;
+function mapDriveItem(item, snippet) {
+    return {
+        itemId: item.id ?? "",
+        driveId: item.parentReference?.driveId,
+        name: item.name ?? "",
+        mimeType: item.file?.mimeType,
+        webUrl: item.webUrl,
+        snippet,
+        lastModified: item.lastModifiedDateTime,
+    };
+}
+function dedupeByItemIdKeepFirst(files) {
+    const seen = new Set();
+    return files.filter(file => {
+        if (seen.has(file.itemId))
+            return false;
+        seen.add(file.itemId);
+        return true;
+    });
+}
+/** POST /search/query, optionally KQL path-scoped — requires Sites.Read.All. */
+async function searchWithSearchApi(query, pathScope, limit, headers) {
+    const queryString = pathScope ? `${query} path:"${pathScope}"` : query;
+    const files = [];
+    let truncated = false;
+    let from = 0;
+    let moreResultsAvailable = false;
+    do {
+        const response = await axiosClient.post(`${MICROSOFT_GRAPH_API_URL}/search/query`, {
+            requests: [
+                {
+                    entityTypes: ["driveItem"],
+                    query: { queryString },
+                    from,
+                    size: SEARCH_PAGE_SIZE,
+                },
+            ],
+        }, { headers });
+        const container = response.data?.value?.[0]?.hitsContainers?.[0];
+        const hits = container?.hits ?? [];
+        moreResultsAvailable = Boolean(container?.moreResultsAvailable);
+        if (hits.length === 0)
+            break;
+        // Truncation is detected in two places because each sees a case the other can't:
+        // here, stopping mid-page with unconsumed hits in hand (moreResultsAvailable can be
+        // false then — it only signals more pages on the server, not leftovers in this page);
+        for (const hit of hits) {
+            if (files.length >= limit) {
+                truncated = true;
+                break;
+            }
+            files.push(mapDriveItem(hit.resource ?? {}, hit.summary));
+        }
+        from += hits.length;
+    } while (!truncated && moreResultsAvailable && files.length < limit);
+    // and here, the limit exactly consumed the page (no hit was encountered past the
+    // limit, so the in-loop check never fired) while the server still has more pages.
+    if (files.length >= limit && moreResultsAvailable) {
+        truncated = true;
+    }
+    return { success: true, files: dedupeByItemIdKeepFirst(files), truncated };
+}
+/** Item-scoped GET /drives/{driveId}/items/{itemId}/search — works with Files.Read.All alone. */
+async function searchWithinFolder(driveId, itemId, query, limit, headers) {
+    const escapedQuery = encodeURIComponent(query.replace(/'/g, "''"));
+    const base = itemId === "root"
+        ? `${MICROSOFT_GRAPH_API_URL}/drives/${driveId}/root`
+        : `${MICROSOFT_GRAPH_API_URL}/drives/${driveId}/items/${itemId}`;
+    const files = [];
+    let truncated = false;
+    let nextUrl = `${base}/search(q='${escapedQuery}')?$top=${SEARCH_PAGE_SIZE}`;
+    while (!truncated && nextUrl) {
+        const response = await axiosClient.get(nextUrl, { headers });
+        const items = response.data.value ?? [];
+        for (const item of items) {
+            if (files.length >= limit) {
+                truncated = true;
+                break;
+            }
+            files.push(mapDriveItem(item));
+        }
+        nextUrl = response.data["@odata.nextLink"];
+    }
+    if (files.length >= limit && nextUrl) {
+        truncated = true;
+    }
+    return { success: true, files: dedupeByItemIdKeepFirst(files), truncated };
+}
+const searchSharepoint = async ({ params, authParams, }) => {
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    const { query, scopeUrl } = params;
+    if (params.limit != null && (!Number.isFinite(params.limit) || params.limit <= 0)) {
+        return { success: false, error: "limit must be a positive number" };
+    }
+    const limit = params.limit ?? DEFAULT_LIMIT;
+    const headers = { Authorization: `Bearer ${authParams.authToken}` };
+    try {
+        if (!scopeUrl) {
+            try {
+                return await searchWithSearchApi(query, undefined, limit, headers);
+            }
+            catch (error) {
+                if (isSiteScopeError(error)) {
+                    return { success: false, error: MISSING_SITES_SCOPE_MESSAGE };
+                }
+                throw error;
+            }
+        }
+        // Resolving the scopeUrl decides the search mode: folders and library roots use an
+        // item-scoped drive search (Files.Read.All alone), sites use the path-filtered Search API
+        const resolved = await resolveItemFromUrl(authParams.authToken, scopeUrl);
+        if (resolved.itemType === "folder") {
+            return await searchWithinFolder(resolved.driveId, resolved.itemId, query, limit, headers);
+        }
+        if (resolved.itemType === "site") {
+            try {
+                return await searchWithSearchApi(query, resolved.webUrl ?? scopeUrl, limit, headers);
+            }
+            catch (error) {
+                if (isSiteScopeError(error)) {
+                    return { success: false, error: MISSING_SITES_SCOPE_MESSAGE };
+                }
+                throw error;
+            }
+        }
+        return {
+            success: false,
+            error: `scopeUrl points to a ${resolved.itemType === "page" ? "site page" : "file"} — provide a folder, document library, or site URL`,
+        };
+    }
+    catch (error) {
+        console.error("Error searching SharePoint", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+};
+export default searchSharepoint;

package/dist/actions/providers/microsoft/sharepointUtils.d.ts

@@ -0,0 +1,56 @@
+export declare const MISSING_SITES_SCOPE_MESSAGE = "Missing Sites.Read.All: this token only permits file/folder access. Site, page, and site-wide search operations require re-authentication with sites scopes.";
+/**
+ * Encodes a URL into a Microsoft Graph share token usable with the /shares endpoint:
+ * "u!" + unpadded base64url of the URL.
+ */
+export declare function encodeShareUrl(url: string): string;
+export type SharepointDriveItem = {
+    id?: string;
+    name?: string;
+    webUrl?: string;
+    size?: number;
+    lastModifiedDateTime?: string;
+    file?: {
+        mimeType?: string;
+    };
+    folder?: {
+        childCount?: number;
+    };
+    parentReference?: {
+        driveId?: string;
+        siteId?: string;
+    };
+};
+export type ResolvedSharepointItem = {
+    itemType: "file" | "folder";
+    driveId: string;
+    itemId: string;
+    siteId?: string;
+    name?: string;
+    webUrl?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+} | {
+    itemType: "site";
+    siteId: string;
+    name?: string;
+    webUrl?: string;
+} | {
+    itemType: "page";
+    siteId: string;
+    pageId?: string;
+    name?: string;
+    webUrl?: string;
+};
+export declare function isSiteScopeError(error: unknown): boolean;
+/**
+ * Resolves any pasted SharePoint/OneDrive URL (file, folder, Office web-viewer link, bare site,
+ * subsite, root site, site page, OneDrive share link) to Graph identifiers.
+ *
+ * Resolution order: SitePages URLs go to the Pages API; everything else probes /shares first
+ * (files/folders, cheap, Files.Read.All only), then falls back to site resolution on any 4xx —
+ * URL shape cannot distinguish a subsite from a folder path, so probing is the only correct
+ * strategy. Throws Error(MISSING_SITES_SCOPE_MESSAGE) when a site-level call fails with 401/403;
+ * when both probes fail, throws a combined error naming both statuses.
+ */
+export declare function resolveItemFromUrl(authToken: string, url: string): Promise<ResolvedSharepointItem>;

package/dist/actions/providers/microsoft/sharepointUtils.js

@@ -0,0 +1,153 @@
+import { ApiError, axiosClient } from "../../util/axiosClient.js";
+import { MICROSOFT_GRAPH_API_URL } from "./utils.js";
+export const MISSING_SITES_SCOPE_MESSAGE = "Missing Sites.Read.All: this token only permits file/folder access. Site, page, and site-wide search operations require re-authentication with sites scopes.";
+/**
+ * Encodes a URL into a Microsoft Graph share token usable with the /shares endpoint:
+ * "u!" + unpadded base64url of the URL.
+ */
+export function encodeShareUrl(url) {
+    const base64 = Buffer.from(url, "utf-8").toString("base64");
+    return "u!" + base64.replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+export function isSiteScopeError(error) {
+    return error instanceof ApiError && (error.status === 401 || error.status === 403);
+}
+/** GET /sites/{hostname}:{serverRelativePath} — requires Sites.Read.All. */
+async function getSiteByPath(hostname, serverRelativePath, headers) {
+    const path = serverRelativePath.replace(/\/+$/, "");
+    // An empty path means the tenant's root site, which Graph addresses without the :path suffix
+    const requestUrl = path
+        ? `${MICROSOFT_GRAPH_API_URL}/sites/${hostname}:${path}`
+        : `${MICROSOFT_GRAPH_API_URL}/sites/${hostname}`;
+    try {
+        const response = await axiosClient.get(requestUrl, { headers });
+        return response.data;
+    }
+    catch (error) {
+        // Capability is detected by attempting the call: a 401/403 here means the token lacks site scopes
+        if (isSiteScopeError(error)) {
+            throw new Error(MISSING_SITES_SCOPE_MESSAGE, { cause: error });
+        }
+        throw error;
+    }
+}
+/** Finds a site page's ID by its file name (e.g. "Home.aspx") — requires Sites.Read.All. */
+async function findSitePageByName(siteId, pageName, headers) {
+    const pagesUrl = `${MICROSOFT_GRAPH_API_URL}/sites/${siteId}/pages/microsoft.graph.sitePage`;
+    try {
+        // Try a server-side filter first to avoid enumerating every page in the site.
+        // Caveat: the docs list $filter as supported, but Graph is known to silently
+        // ignore name filters on this endpoint, so treat the response defensively.
+        const escapedName = pageName.replace(/'/g, "''");
+        const filtered = await axiosClient.get(`${pagesUrl}?$filter=${encodeURIComponent(`name eq '${escapedName}'`)}`, { headers });
+        const match = (filtered.data.value ?? []).find(page => page.name?.toLowerCase() === pageName.toLowerCase());
+        if (match != null)
+            return match;
+        // No match and no further pages: whether the filter was honored (empty result) or
+        // ignored (we saw the complete unfiltered set), the page isn't there.
+        if (filtered.data["@odata.nextLink"] == null)
+            return undefined;
+        // No match but more pages exist — the filter was likely ignored (a known Graph gap
+        // for sitePage name filtering); fall through to full enumeration.
+    }
+    catch (error) {
+        if (isSiteScopeError(error)) {
+            throw new Error(MISSING_SITES_SCOPE_MESSAGE, { cause: error });
+        }
+        // Some tenants reject $filter on this endpoint outright — fall back to enumeration
+        if (!(error instanceof ApiError && error.status === 400)) {
+            throw error;
+        }
+    }
+    let nextUrl = `${pagesUrl}?$top=100`;
+    try {
+        while (nextUrl) {
+            const response = await axiosClient.get(nextUrl, { headers });
+            const pages = response.data.value ?? [];
+            const match = pages.find(page => page.name?.toLowerCase() === pageName.toLowerCase());
+            if (match != null)
+                return match;
+            nextUrl = response.data["@odata.nextLink"];
+        }
+    }
+    catch (error) {
+        if (isSiteScopeError(error)) {
+            throw new Error(MISSING_SITES_SCOPE_MESSAGE, { cause: error });
+        }
+        throw error;
+    }
+    return undefined;
+}
+/**
+ * Resolves any pasted SharePoint/OneDrive URL (file, folder, Office web-viewer link, bare site,
+ * subsite, root site, site page, OneDrive share link) to Graph identifiers.
+ *
+ * Resolution order: SitePages URLs go to the Pages API; everything else probes /shares first
+ * (files/folders, cheap, Files.Read.All only), then falls back to site resolution on any 4xx —
+ * URL shape cannot distinguish a subsite from a folder path, so probing is the only correct
+ * strategy. Throws Error(MISSING_SITES_SCOPE_MESSAGE) when a site-level call fails with 401/403;
+ * when both probes fail, throws a combined error naming both statuses.
+ */
+export async function resolveItemFromUrl(authToken, url) {
+    const headers = { Authorization: `Bearer ${authToken}` };
+    const parsed = new URL(url);
+    // Site pages: https://{tenant}.sharepoint.com/sites/{site}/SitePages/{page}.aspx
+    const sitePageMatch = parsed.pathname.match(/^(.*)\/SitePages\/([^/]+\.aspx)$/i);
+    if (sitePageMatch) {
+        const [, sitePath, pageFileName] = sitePageMatch;
+        const pageName = decodeURIComponent(pageFileName);
+        const site = await getSiteByPath(parsed.hostname, sitePath, headers);
+        const page = await findSitePageByName(site.id, pageName, headers);
+        return {
+            itemType: "page",
+            siteId: site.id,
+            pageId: page?.id,
+            name: page?.title ?? page?.name ?? pageName,
+            webUrl: page?.webUrl ?? url,
+        };
+    }
+    // The /shares resolver handles files, folders, Doc.aspx web-viewer links, OneDrive personal
+    // and 1drv.ms share links with Files.Read.All alone
+    let shareError;
+    try {
+        const response = await axiosClient.get(`${MICROSOFT_GRAPH_API_URL}/shares/${encodeShareUrl(url)}/driveItem`, {
+            headers,
+        });
+        const item = response.data;
+        if (item?.id && item?.parentReference?.driveId) {
+            return {
+                itemType: item.folder ? "folder" : "file",
+                driveId: item.parentReference.driveId,
+                itemId: item.id,
+                siteId: item.parentReference.siteId,
+                name: item.name,
+                webUrl: item.webUrl,
+                mimeType: item.file?.mimeType,
+                sizeBytes: item.size,
+            };
+        }
+        throw new Error(`Unable to resolve URL to a drive item: ${url}`);
+    }
+    catch (error) {
+        // A site is not a drive item, so /shares rejects site URLs with a 4xx. URL shape cannot
+        // distinguish a subsite from a folder path, so we always probe /shares first and, on any
+        // client error, fall back to resolving the path as a site. 5xx/network errors are real
+        // failures and are rethrown immediately.
+        if (!(error instanceof ApiError && error.status !== undefined && error.status < 500)) {
+            throw error;
+        }
+        shareError = error;
+    }
+    try {
+        const site = await getSiteByPath(parsed.hostname, parsed.pathname, headers);
+        return { itemType: "site", siteId: site.id, name: site.displayName, webUrl: site.webUrl };
+    }
+    catch (siteError) {
+        // A missing sites scope is the more actionable diagnosis — surface it as-is
+        if (siteError instanceof Error && siteError.message === MISSING_SITES_SCOPE_MESSAGE) {
+            throw siteError;
+        }
+        const siteStatus = siteError instanceof ApiError && siteError.status !== undefined ? siteError.status : "error";
+        throw new Error(`Unable to resolve URL: not a document or folder (/shares: ${shareError?.status ?? "error"}) and not a site (/sites: ${siteStatus}): ${url}`, { cause: siteError });
+    }
+}

package/dist/actions/providers/microsoft/utils.d.ts

@@ -7,3 +7,4 @@ export declare function getGraphClient(authParams: AuthParamsType): Promise<Clie
  * @returns A sanitized filename that is safe to use.
  */
 export declare function validateAndSanitizeFileName(fileName: string): string;
+export declare const MICROSOFT_GRAPH_API_URL = "https://graph.microsoft.com/v1.0";

package/dist/actions/providers/microsoft/utils.js

@@ -33,3 +33,4 @@ export function validateAndSanitizeFileName(fileName) {
     }
     return sanitizedFileName;
 }
+export const MICROSOFT_GRAPH_API_URL = "https://graph.microsoft.com/v1.0";

package/dist/actions/providers/servicenow/getChangeRequests.d.ts

@@ -0,0 +1,3 @@
+import type { servicenowGetChangeRequestsFunction } from "../../autogen/types.js";
+declare const getChangeRequests: servicenowGetChangeRequestsFunction;
+export default getChangeRequests;

package/dist/actions/providers/servicenow/getChangeRequests.js

@@ -0,0 +1,56 @@
+import { computeTimeToClosureMinutes, extractAdditionalFields, queryServiceNowTable } from "./utils/tableQuery.js";
+const CHANGE_REQUEST_FIELDS = [
+    "number",
+    "short_description",
+    "description",
+    "state",
+    "priority",
+    "impact",
+    "urgency",
+    "requested_by",
+    "assigned_to",
+    "assignment_group",
+    "opened_at",
+    "sys_updated_on",
+    "closed_at",
+    "work_notes",
+    "comments",
+];
+const getChangeRequests = async ({ params, authParams, }) => {
+    const { query, additionalFields, limit, offset } = params;
+    const result = await queryServiceNowTable({
+        authParams,
+        tableName: "change_request",
+        fields: CHANGE_REQUEST_FIELDS,
+        filter: query,
+        additionalFields,
+        limit,
+        offset,
+    });
+    if ("error" in result) {
+        return { success: false, error: result.error };
+    }
+    return {
+        success: true,
+        records: result.records.map(record => ({
+            number: record.number,
+            requestor: record.requested_by,
+            assignee: record.assigned_to,
+            assignmentGroup: record.assignment_group,
+            shortDescription: record.short_description,
+            description: record.description,
+            state: record.state,
+            priority: record.priority,
+            impact: record.impact,
+            urgency: record.urgency,
+            openedAt: record.opened_at,
+            updatedAt: record.sys_updated_on,
+            closedAt: record.closed_at,
+            workNotes: record.work_notes,
+            comments: record.comments,
+            timeToClosureMinutes: computeTimeToClosureMinutes(record.opened_at, record.closed_at),
+            extraFields: extractAdditionalFields(record, additionalFields),
+        })),
+    };
+};
+export default getChangeRequests;

package/dist/actions/providers/servicenow/getIncidents.d.ts

@@ -0,0 +1,3 @@
+import type { servicenowGetIncidentsFunction } from "../../autogen/types.js";
+declare const getIncidents: servicenowGetIncidentsFunction;
+export default getIncidents;

package/dist/actions/providers/servicenow/getIncidents.js

@@ -0,0 +1,58 @@
+import { computeTimeToClosureMinutes, extractAdditionalFields, queryServiceNowTable } from "./utils/tableQuery.js";
+const INCIDENT_FIELDS = [
+    "number",
+    "short_description",
+    "description",
+    "state",
+    "incident_state",
+    "priority",
+    "impact",
+    "urgency",
+    "caller_id",
+    "assigned_to",
+    "assignment_group",
+    "opened_at",
+    "sys_updated_on",
+    "closed_at",
+    "work_notes",
+    "comments",
+];
+const getIncidents = async ({ params, authParams, }) => {
+    const { query, additionalFields, limit, offset } = params;
+    const result = await queryServiceNowTable({
+        authParams,
+        tableName: "incident",
+        fields: INCIDENT_FIELDS,
+        filter: query,
+        additionalFields,
+        limit,
+        offset,
+    });
+    if ("error" in result) {
+        return { success: false, error: result.error };
+    }
+    return {
+        success: true,
+        records: result.records.map(record => ({
+            number: record.number,
+            caller: record.caller_id,
+            assignee: record.assigned_to,
+            assignmentGroup: record.assignment_group,
+            shortDescription: record.short_description,
+            description: record.description,
+            state: record.state,
+            incidentState: record.incident_state,
+            priority: record.priority,
+            impact: record.impact,
+            urgency: record.urgency,
+            openedAt: record.opened_at,
+            updatedAt: record.sys_updated_on,
+            closedAt: record.closed_at,
+            workNotes: record.work_notes,
+            comments: record.comments,
+            timeToClosureMinutes: computeTimeToClosureMinutes(record.opened_at, record.closed_at),
+            extraFields: extractAdditionalFields(record, additionalFields),
+        })),
+    };
+};
+export default getIncidents;

package/dist/actions/providers/servicenow/getRecordsByQuery.d.ts

@@ -0,0 +1,3 @@
+import type { servicenowGetRecordsByQueryFunction } from "../../autogen/types.js";
+declare const getRecordsByQuery: servicenowGetRecordsByQueryFunction;
+export default getRecordsByQuery;