@credal/actions 0.2.223 → 0.2.225

package/dist/actions/providers/kandji/getFVRecoveryKeyForDevice.js

@@ -0,0 +1,85 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+const getFVRecoveryKeyForDevice = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { userEmail, subdomain } = params;
+    const { apiKey } = authParams;
+    if (!apiKey) {
+        throw new Error("Missing API key in auth parameters");
+    }
+    try {
+        // First list all devices to get the device for the specific device
+        const device = yield getDeviceByEmail({
+            apiKey,
+            userEmail,
+            subdomain,
+        });
+        if (!device) {
+            return {
+                success: false,
+                error: "Device not found for the given serial number",
+            };
+        }
+        // Then get the FV recovery key for that device
+        const fvRecoveryKey = yield axiosClient.get(`https://${subdomain}.api.kandji.io/api/v1/devices/${device.device_id}/secrets/filevaultkey`, {
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+        if (!fvRecoveryKey || !fvRecoveryKey.data || !fvRecoveryKey.data.key) {
+            return {
+                success: false,
+                error: "FireVault recovery key not found",
+            };
+        }
+        return {
+            success: true,
+            recoveryKey: fvRecoveryKey.data.key,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+function getDeviceByEmail(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limit = 300;
+        let offset = 0;
+        const { apiKey, userEmail, subdomain } = input;
+        while (true) {
+            // Update params
+            const params = { limit, offset };
+            const endpoint = `https://${subdomain}.api.kandji.io/api/v1/devices`;
+            const response = yield axiosClient.get(endpoint, {
+                params: Object.assign({}, params),
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+            for (const device of response.data) {
+                if (device.user && device.user.email === userEmail) {
+                    // If the device user email matches, return the device
+                    return device;
+                }
+            }
+            offset += limit;
+            if (response.data.length === 0) {
+                break;
+            }
+        }
+        return null;
+    });
+}
+export default getFVRecoveryKeyForDevice;

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

@@ -1,6 +1,6 @@
-import { getGraphClient, validateAndSanitizeFileName } from "./utils.js";
+import { getDrivePath, getGraphClient, validateAndSanitizeFileName } from "./utils.js";
 const createDocument = async ({ params, authParams, }) => {
-    const { folderId, name, content, siteId } = params;
+    const { folderId, name, content, siteId, driveId } = params;
     let client = undefined;
     try {
         client = await getGraphClient(authParams);
@@ -11,9 +11,8 @@ const createDocument = async ({ params, authParams, }) => {
             error: "Error while authorizing: " + (error instanceof Error ? error.message : "Unknown error"),
         };
     }
-    const apiEndpointPrefix = siteId ? `/sites/${siteId}` : "/me";
     const sanitizedFileName = validateAndSanitizeFileName(name);
-    const endpoint = `${apiEndpointPrefix}/drive/items/${folderId || "root"}:/${sanitizedFileName}:/content`;
+    const endpoint = `${getDrivePath({ driveId, siteId })}/items/${folderId || "root"}:/${sanitizedFileName}:/content`;
     try {
         // Create or update the document
         const response = await client.api(endpoint).put(content);

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

@@ -1,6 +1,6 @@
-import { getGraphClient } from "./utils.js";
+import { getDrivePath, getGraphClient } from "./utils.js";
 const getDocument = async ({ params, authParams, }) => {
-    const { siteId, documentId } = params;
+    const { siteId, driveId, documentId } = params;
     let client;
     try {
         client = await getGraphClient(authParams);
@@ -12,10 +12,7 @@ const getDocument = async ({ params, authParams, }) => {
         };
     }
     try {
-        // Construct the API endpoint
-        const endpoint = siteId
-            ? `/sites/${siteId}/drive/items/${documentId}/content`
-            : `/me/drive/items/${documentId}/content`;
+        const endpoint = `${getDrivePath({ driveId, siteId })}/items/${documentId}/content`;
         // Fetch the document content
         const response = await client.api(endpoint).get();
         return {

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

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

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

@@ -0,0 +1,61 @@
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { axiosClient } from "../../util/axiosClient.js";
+import { MICROSOFT_GRAPH_API_URL } from "./utils.js";
+import { resolveItemFromUrl } from "./sharepointUtils.js";
+const getSharepointItem = async ({ params, authParams, }) => {
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    try {
+        const resolved = await resolveItemFromUrl(authParams.authToken, params.url);
+        if (resolved.itemType === "site") {
+            const drivesResponse = await axiosClient.get(`${MICROSOFT_GRAPH_API_URL}/sites/${resolved.siteId}/drives`, {
+                headers: { Authorization: `Bearer ${authParams.authToken}` },
+            });
+            const drives = drivesResponse.data.value ?? [];
+            return {
+                success: true,
+                item: {
+                    itemType: "site",
+                    siteId: resolved.siteId,
+                    name: resolved.name,
+                    webUrl: resolved.webUrl,
+                    drives: drives.map(drive => ({ driveId: drive.id, name: drive.name, webUrl: drive.webUrl })),
+                },
+            };
+        }
+        if (resolved.itemType === "page") {
+            return {
+                success: true,
+                item: {
+                    itemType: "page",
+                    siteId: resolved.siteId,
+                    itemId: resolved.pageId,
+                    name: resolved.name,
+                    webUrl: resolved.webUrl,
+                },
+            };
+        }
+        return {
+            success: true,
+            item: {
+                itemType: resolved.itemType,
+                name: resolved.name,
+                webUrl: resolved.webUrl,
+                driveId: resolved.driveId,
+                itemId: resolved.itemId,
+                siteId: resolved.siteId,
+                mimeType: resolved.mimeType,
+                sizeBytes: resolved.sizeBytes,
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error resolving SharePoint item from URL", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+};
+export default getSharepointItem;

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

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

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

@@ -0,0 +1,92 @@
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { axiosClient } from "../../util/axiosClient.js";
+import { MICROSOFT_GRAPH_API_URL } from "./utils.js";
+import { resolveItemFromUrl } from "./sharepointUtils.js";
+const DEFAULT_MAX_ITEMS = 200;
+const PAGE_SIZE = 200;
+function buildChildrenUrl(driveId, itemId) {
+    const base = itemId === "root"
+        ? `${MICROSOFT_GRAPH_API_URL}/drives/${driveId}/root/children`
+        : `${MICROSOFT_GRAPH_API_URL}/drives/${driveId}/items/${itemId}/children`;
+    return `${base}?$top=${PAGE_SIZE}`;
+}
+/**
+ * Resolve a pasted URL to the folder to enumerate. Throws when the URL points at
+ * something that cannot be listed (file, page); the action's catch maps the message
+ * onto the error output.
+ */
+async function resolveRootFolderFromUrl(authToken, url, headers) {
+    const resolved = await resolveItemFromUrl(authToken, url);
+    if (resolved.itemType === "file") {
+        throw new Error("The URL points to a file, not a folder. Use readSharepointContent instead.");
+    }
+    if (resolved.itemType === "page") {
+        throw new Error("The URL points to a site page, not a folder. Use readSharepointContent instead.");
+    }
+    if (resolved.itemType === "site") {
+        // A site URL lists the root of the site's default document library
+        const driveResponse = await axiosClient.get(`${MICROSOFT_GRAPH_API_URL}/sites/${resolved.siteId}/drive`, {
+            headers,
+        });
+        return { driveId: driveResponse.data.id, itemId: "root" };
+    }
+    return { driveId: resolved.driveId, itemId: resolved.itemId };
+}
+const listSharepointFolder = async ({ params, authParams, }) => {
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    const { url, driveItem, recursive = false } = params;
+    if (params.maxItems != null && (!Number.isFinite(params.maxItems) || params.maxItems <= 0)) {
+        return { success: false, error: "maxItems must be a positive number" };
+    }
+    const maxItems = params.maxItems ?? DEFAULT_MAX_ITEMS;
+    if (!url && !driveItem) {
+        return { success: false, error: "Either url or driveItem must be provided" };
+    }
+    const headers = { Authorization: `Bearer ${authParams.authToken}` };
+    try {
+        const rootFolder = driveItem ?? (await resolveRootFolderFromUrl(authParams.authToken, url, headers));
+        const items = [];
+        let truncated = false;
+        const queue = [rootFolder];
+        outer: while (queue.length > 0) {
+            const folder = queue.shift();
+            let nextUrl = buildChildrenUrl(folder.driveId, folder.itemId);
+            while (nextUrl) {
+                const response = await axiosClient.get(nextUrl, { headers });
+                const children = response.data.value ?? [];
+                for (const child of children) {
+                    if (items.length >= maxItems) {
+                        truncated = true;
+                        break outer;
+                    }
+                    const childDriveId = child.parentReference?.driveId ?? folder.driveId;
+                    items.push({
+                        itemId: child.id ?? "",
+                        driveId: childDriveId,
+                        name: child.name ?? "",
+                        itemType: child.folder ? "folder" : "file",
+                        mimeType: child.file?.mimeType,
+                        sizeBytes: child.size,
+                        webUrl: child.webUrl,
+                        lastModified: child.lastModifiedDateTime,
+                    });
+                    if (recursive && child.folder && child.id) {
+                        queue.push({ driveId: childDriveId, itemId: child.id });
+                    }
+                }
+                nextUrl = response.data["@odata.nextLink"];
+            }
+        }
+        return { success: true, items, truncated };
+    }
+    catch (error) {
+        console.error("Error listing SharePoint folder", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+};
+export default listSharepointFolder;

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

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

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/sendOutlookEmail.d.ts

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

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

@@ -0,0 +1,48 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getGraphClient } from "./utils.js";
+const sendEmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { toRecipients, subject, body, ccRecipients, bccRecipients } = params;
+    let client = undefined;
+    try {
+        client = yield getGraphClient(authParams);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: "Error while authorizing: " + (error instanceof Error ? error.message : "Unknown error"),
+        };
+    }
+    try {
+        const message = {
+            message: Object.assign(Object.assign({ subject, body: {
+                    contentType: "HTML",
+                    content: body,
+                }, toRecipients: toRecipients.map(email => ({ emailAddress: { address: email } })) }, (ccRecipients && ccRecipients.length > 0
+                ? { ccRecipients: ccRecipients.map(email => ({ emailAddress: { address: email } })) }
+                : {})), (bccRecipients && bccRecipients.length > 0
+                ? { bccRecipients: bccRecipients.map(email => ({ emailAddress: { address: email } })) }
+                : {})),
+            saveToSentItems: true,
+        };
+        yield client.api("/me/sendMail").post(message);
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            success: false,
+            error: "Error sending email: " + (error instanceof Error ? error.message : "Unknown error"),
+        };
+    }
+});
+export default sendEmail;