wizards 0.1.9

package/apps/runtime/dist/engenty/connections-hubspot/connector.js

@@ -0,0 +1,140 @@
+import { defineConnector, } from "../shims/connections-sdk.js";
+import { z } from "zod";
+const HUBSPOT_API = "https://api.hubapi.com";
+function parseCredentials(accessToken) {
+    let parsed;
+    try {
+        parsed = JSON.parse(accessToken);
+    }
+    catch {
+        throw new Error("hubspot_credentials_invalid: stored credentials are not JSON");
+    }
+    if (!parsed.access_token?.trim()) {
+        throw new Error("hubspot_credentials_invalid: missing access_token");
+    }
+    return { access_token: parsed.access_token.trim() };
+}
+async function errorExcerpt(res) {
+    const body = await res.text().catch(() => "");
+    return body.replace(/\s+/g, " ").trim().slice(0, 200) || res.statusText;
+}
+async function hubspotJson(ctx, path, init) {
+    const creds = parseCredentials(ctx.accessToken);
+    const res = await ctx.fetchImpl(`${HUBSPOT_API}${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${creds.access_token}`,
+            "content-type": "application/json",
+            ...(init?.headers ?? {}),
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`hubspot_api_error (${res.status}): ${await errorExcerpt(res)}`);
+    }
+    return (await res.json());
+}
+function mapContact(contact) {
+    const p = contact.properties ?? {};
+    const displayName = [p.firstname, p.lastname].filter(Boolean).join(" ").trim() ||
+        p.email ||
+        null;
+    return {
+        company: p.company ?? null,
+        display_name: displayName,
+        email: p.email ?? null,
+        first_name: p.firstname ?? null,
+        hubspot_id: contact.id,
+        last_name: p.lastname ?? null,
+        phone: p.phone ?? null,
+        title: p.jobtitle ?? null,
+    };
+}
+function connectorAction(def) {
+    return {
+        description: def.description,
+        group: def.group,
+        handler: (input, ctx) => def.handler(def.inputSchema.parse(input), ctx),
+        id: def.id,
+        inputSchema: def.inputSchema,
+        providerScopes: [],
+        summary: def.summary,
+    };
+}
+export async function verifyHubSpotCredentials(raw, fetchImpl) {
+    const token = raw.access_token?.trim();
+    if (!token) {
+        throw new Error("missing access_token");
+    }
+    const res = await fetchImpl(`${HUBSPOT_API}/crm/v3/objects/contacts?limit=1`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+        throw new Error(`hubspot_verify_failed (${res.status}): ${await errorExcerpt(res)}`);
+    }
+    // Account details require a separate scopes-heavy call; use a stable label.
+    return { label: "HubSpot" };
+}
+export const hubspotConnector = defineConnector({
+    actions: [
+        connectorAction({
+            description: "List HubSpot CRM contacts. Returns compact rows for import: display name, first/last name, email, phone, company, title, hubspot_id.",
+            group: "read",
+            handler: async (input, ctx) => {
+                const params = new URLSearchParams({
+                    limit: String(input.page_size ?? 100),
+                    properties: [
+                        "email",
+                        "firstname",
+                        "lastname",
+                        "phone",
+                        "company",
+                        "jobtitle",
+                    ].join(","),
+                });
+                if (input.page_token) {
+                    params.set("after", input.page_token);
+                }
+                const data = await hubspotJson(ctx, `/crm/v3/objects/contacts?${params.toString()}`);
+                return {
+                    contacts: (data.results ?? []).map(mapContact),
+                    next_page_token: data.paging?.next?.after ?? null,
+                };
+            },
+            id: "list_contacts",
+            inputSchema: z.object({
+                page_size: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(100)
+                    .optional()
+                    .describe("Page size (1–100). Defaults to 100."),
+                page_token: z
+                    .string()
+                    .optional()
+                    .describe("Pagination cursor from a previous list_contacts call."),
+            }),
+            summary: "List HubSpot contacts",
+        }),
+    ],
+    auth: {
+        kind: "api_key",
+        apiKey: {
+            fields: [
+                {
+                    key: "access_token",
+                    label: "Private app access token",
+                    placeholder: "pat-…",
+                    secret: true,
+                },
+            ],
+            verify: verifyHubSpotCredentials,
+        },
+    },
+    description: "Import contacts from HubSpot CRM using a private app access token.",
+    icon: "🔌",
+    id: "hubspot",
+    moduleId: "connections-hubspot",
+    name: "HubSpot",
+    toolPrefix: "hubspot",
+});

package/apps/runtime/dist/engenty/connections-microsoft/action.js

@@ -0,0 +1,17 @@
+/**
+ * Typed action builder: `ConnectorAction[]` erases the input type to
+ * `unknown`, so handlers written against concrete inputs would violate
+ * strictFunctionTypes. This wrapper parses the raw input with the action's
+ * zod schema (also applying schema defaults) before invoking the typed `run`.
+ */
+export function action(def) {
+    return {
+        description: def.description,
+        group: def.group,
+        handler: (raw, ctx) => def.run(def.inputSchema.parse(raw), ctx),
+        id: def.id,
+        inputSchema: def.inputSchema,
+        providerScopes: def.providerScopes,
+        summary: def.summary,
+    };
+}

package/apps/runtime/dist/engenty/connections-microsoft/graph.js

@@ -0,0 +1,114 @@
+export const GRAPH_BASE_URL = "https://graph.microsoft.com/v1.0";
+/**
+ * Shared Microsoft identity platform OAuth config (tenant `common`, so both
+ * org and personal Microsoft accounts can connect). Both connectors reuse it;
+ * per-action `providerScopes` add the Graph delegated permissions on top of
+ * these base identity scopes.
+ */
+export const MICROSOFT_OAUTH2 = {
+    authUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+    baseScopes: ["openid", "email", "offline_access", "User.Read"],
+    clientIdEnv: "MICROSOFT_OAUTH_CLIENT_ID",
+    clientSecretEnv: "MICROSOFT_OAUTH_CLIENT_SECRET",
+    resolveAccount: async (accessToken, fetchImpl) => {
+        const res = await fetchImpl(`${GRAPH_BASE_URL}/me`, {
+            headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        if (!res.ok) {
+            throw new Error(`microsoft_graph_error (${res.status}): failed to resolve account via /me`);
+        }
+        const me = (await res.json());
+        return {
+            externalId: me.id,
+            label: me.userPrincipalName ?? me.mail ?? "Microsoft account",
+        };
+    },
+    tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+};
+async function graphError(res) {
+    let excerpt = "";
+    try {
+        excerpt = (await res.text()).replace(/\s+/g, " ").trim().slice(0, 300);
+    }
+    catch {
+        // ignore body read failures — status alone is enough
+    }
+    return new Error(`microsoft_graph_error (${res.status}): ${excerpt || res.statusText}`);
+}
+/**
+ * JSON request against Microsoft Graph. `path` is relative to the v1.0 base
+ * (must start with `/`). Returns the parsed JSON body, or `null` for
+ * 202/204-style empty responses.
+ */
+export async function graphJson(ctx, path, init) {
+    const res = await ctx.fetchImpl(`${GRAPH_BASE_URL}${path}`, {
+        headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${ctx.accessToken}`,
+            ...(init?.body === undefined
+                ? {}
+                : { "Content-Type": "application/json" }),
+        },
+        method: init?.method ?? "GET",
+        ...(init?.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+    });
+    if (!res.ok) {
+        throw await graphError(res);
+    }
+    if (res.status === 204 ||
+        res.status === 202 ||
+        res.headers.get("content-length") === "0") {
+        return null;
+    }
+    const text = await res.text();
+    if (!text) {
+        return null;
+    }
+    return JSON.parse(text);
+}
+/** Raw (non-JSON) Graph request — used for file content and uploads. */
+export async function graphRaw(ctx, path, init) {
+    const res = await ctx.fetchImpl(`${GRAPH_BASE_URL}${path}`, {
+        headers: {
+            Authorization: `Bearer ${ctx.accessToken}`,
+            ...(init?.contentType ? { "Content-Type": init.contentType } : {}),
+        },
+        method: init?.method ?? "GET",
+        ...(init?.body === undefined ? {} : { body: init.body }),
+    });
+    if (!res.ok) {
+        throw await graphError(res);
+    }
+    return res;
+}
+/** Very small HTML → plain-text conversion for message/event bodies. */
+export function htmlToText(html) {
+    return html
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<head[\s\S]*?<\/head>/gi, " ")
+        .replace(/<!--[\s\S]*?-->/g, " ")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|tr|li|blockquote|h[1-6])>/gi, "\n")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&amp;/gi, "&")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#0?39;/g, "'")
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/** Body from a Graph message/event `itemBody`, normalized to plain text. */
+export function bodyToText(body) {
+    const content = body?.content ?? "";
+    if (!content) {
+        return "";
+    }
+    return body?.contentType?.toLowerCase() === "html"
+        ? htmlToText(content)
+        : content;
+}

package/apps/runtime/dist/engenty/connections-microsoft/onedrive.js

@@ -0,0 +1,286 @@
+import { defineConnector } from "../shims/connections-sdk.js";
+import { z } from "zod";
+import { action } from "./action.js";
+import { GRAPH_BASE_URL, graphJson, graphRaw, MICROSOFT_OAUTH2, } from "./graph.js";
+const MAX_SEARCH_TOP = 25;
+const MAX_CONTENT_CHARS = 50_000;
+const ITEM_SELECT = "id,name,file,folder,size,lastModifiedDateTime,webUrl";
+function mapItem(item) {
+    return {
+        childCount: item.folder?.childCount ?? null,
+        id: item.id,
+        isFolder: Boolean(item.folder),
+        lastModifiedDateTime: item.lastModifiedDateTime ?? null,
+        mimeType: item.file?.mimeType ?? null,
+        name: item.name ?? null,
+        size: item.size ?? null,
+        webUrl: item.webUrl ?? null,
+    };
+}
+const TEXTISH_MIME_PREFIXES = ["text/"];
+const TEXTISH_MIME_TYPES = new Set([
+    "application/json",
+    "application/ld+json",
+    "application/javascript",
+    "application/typescript",
+    "application/x-javascript",
+    "application/xml",
+    "application/x-sh",
+    "application/x-yaml",
+    "application/yaml",
+    "application/csv",
+    "application/sql",
+    "application/rtf",
+    "image/svg+xml",
+]);
+function toCapabilityEntry(item) {
+    return {
+        kind: item.folder ? "folder" : "file",
+        mime_type: item.file?.mimeType ?? null,
+        modified_at: item.lastModifiedDateTime ?? null,
+        name: item.name ?? "",
+        ref: item.id ?? "",
+        size: item.size ?? null,
+        web_url: item.webUrl ?? null,
+    };
+}
+/** Turn a Graph `@odata.nextLink` (a full URL) into a graphJson-relative path. */
+function nextLinkToCursor(nextLink) {
+    if (!nextLink) {
+        return null;
+    }
+    return nextLink.startsWith(GRAPH_BASE_URL)
+        ? nextLink.slice(GRAPH_BASE_URL.length)
+        : nextLink;
+}
+function isTextishMimeType(mimeType) {
+    const normalized = mimeType.toLowerCase().split(";")[0].trim();
+    return (TEXTISH_MIME_PREFIXES.some((p) => normalized.startsWith(p)) ||
+        TEXTISH_MIME_TYPES.has(normalized) ||
+        normalized.endsWith("+json") ||
+        normalized.endsWith("+xml"));
+}
+export const microsoftOneDriveConnector = defineConnector({
+    actions: [
+        // ── read ────────────────────────────────────────────────────────────
+        action({
+            description: "Search files and folders across the user's OneDrive by name/content query.",
+            group: "read",
+            id: "search_files",
+            inputSchema: z.object({
+                q: z.string().describe("Search text (matches names and file content)."),
+                top: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(MAX_SEARCH_TOP)
+                    .optional()
+                    .describe("Max results to return (1–25, default 10)."),
+            }),
+            providerScopes: ["Files.Read"],
+            run: async (input, ctx) => {
+                const top = Math.min(Math.max(input.top ?? 10, 1), MAX_SEARCH_TOP);
+                const q = encodeURIComponent(input.q.replace(/'/g, "''"));
+                const data = await graphJson(ctx, `/me/drive/root/search(q='${q}')?$top=${top}&$select=${ITEM_SELECT}`);
+                return { items: (data.value ?? []).map(mapItem) };
+            },
+            summary: "Search OneDrive files",
+        }),
+        action({
+            description: "Get metadata for a single OneDrive item (file or folder) by id.",
+            group: "read",
+            id: "get_item",
+            inputSchema: z.object({
+                item_id: z.string().describe("OneDrive item id."),
+            }),
+            providerScopes: ["Files.Read"],
+            run: async (input, ctx) => {
+                const item = await graphJson(ctx, `/me/drive/items/${encodeURIComponent(input.item_id)}?$select=${ITEM_SELECT},parentReference`);
+                return {
+                    ...mapItem(item),
+                    parent: item.parentReference
+                        ? {
+                            id: item.parentReference.id ?? null,
+                            path: item.parentReference.path ?? null,
+                        }
+                        : null,
+                };
+            },
+            summary: "Get a OneDrive item",
+        }),
+        action({
+            description: "List the children of a OneDrive folder (defaults to the drive root).",
+            group: "read",
+            id: "list_children",
+            inputSchema: z.object({
+                item_id: z
+                    .string()
+                    .optional()
+                    .describe("Folder item id. Omit to list the drive root."),
+                top: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(MAX_SEARCH_TOP)
+                    .optional()
+                    .describe("Max children to return (1–25, default 25)."),
+            }),
+            providerScopes: ["Files.Read"],
+            run: async (input, ctx) => {
+                const top = Math.min(Math.max(input.top ?? MAX_SEARCH_TOP, 1), MAX_SEARCH_TOP);
+                const base = input.item_id
+                    ? `/me/drive/items/${encodeURIComponent(input.item_id)}/children`
+                    : "/me/drive/root/children";
+                const data = await graphJson(ctx, `${base}?$top=${top}&$select=${ITEM_SELECT}`);
+                return { items: (data.value ?? []).map(mapItem) };
+            },
+            summary: "List OneDrive folder children",
+        }),
+        action({
+            description: "Read the content of a text-like OneDrive file (capped at ~50KB). Office documents are not converted — their webUrl is returned instead.",
+            group: "read",
+            id: "read_file_content",
+            inputSchema: z.object({
+                item_id: z.string().describe("OneDrive file item id."),
+            }),
+            providerScopes: ["Files.Read"],
+            run: async (input, ctx) => {
+                const encodedId = encodeURIComponent(input.item_id);
+                const item = await graphJson(ctx, `/me/drive/items/${encodedId}?$select=${ITEM_SELECT}`);
+                if (item.folder) {
+                    throw new Error("read_file_content: item is a folder — use list_children instead");
+                }
+                const mimeType = item.file?.mimeType ?? "";
+                if (!(mimeType && isTextishMimeType(mimeType))) {
+                    return {
+                        id: item.id,
+                        mimeType: mimeType || null,
+                        name: item.name ?? null,
+                        reason: "File content is not plain text (e.g. an Office document or binary). Open it via webUrl instead.",
+                        supported: false,
+                        webUrl: item.webUrl ?? null,
+                    };
+                }
+                const res = await graphRaw(ctx, `/me/drive/items/${encodedId}/content`);
+                const text = await res.text();
+                const truncated = text.length > MAX_CONTENT_CHARS;
+                return {
+                    content: truncated ? text.slice(0, MAX_CONTENT_CHARS) : text,
+                    id: item.id,
+                    mimeType,
+                    name: item.name ?? null,
+                    size: item.size ?? null,
+                    supported: true,
+                    truncated,
+                };
+            },
+            summary: "Read a OneDrive text file's content",
+        }),
+        // ── write ───────────────────────────────────────────────────────────
+        action({
+            description: "Upload (create or overwrite) a text file in OneDrive under the given parent folder.",
+            group: "write",
+            id: "upload_file",
+            inputSchema: z.object({
+                content_text: z.string().describe("File content (plain text)."),
+                name: z
+                    .string()
+                    .describe("File name including extension (e.g. notes.md)."),
+                parent_id: z
+                    .string()
+                    .default("root")
+                    .describe('Parent folder item id (default "root").'),
+            }),
+            providerScopes: ["Files.ReadWrite"],
+            run: async (input, ctx) => {
+                const encodedName = encodeURIComponent(input.name);
+                const path = input.parent_id === "root"
+                    ? `/me/drive/root:/${encodedName}:/content`
+                    : `/me/drive/items/${encodeURIComponent(input.parent_id)}:/${encodedName}:/content`;
+                const res = await graphRaw(ctx, path, {
+                    body: input.content_text,
+                    contentType: "text/plain",
+                    method: "PUT",
+                });
+                const item = (await res.json());
+                return mapItem(item);
+            },
+            summary: "Upload a text file to OneDrive",
+        }),
+    ],
+    auth: { kind: "oauth2", oauth2: MICROSOFT_OAUTH2 },
+    description: "OneDrive files via Microsoft Graph: search, browse, read text file content, and upload text files.",
+    files: {
+        rootLabel: () => "OneDrive",
+        async list(ctx, input) {
+            // A cursor is a ready-to-follow @odata.nextLink path (already carries
+            // $top/$select/$skiptoken), so follow it verbatim.
+            const path = input.cursor
+                ? input.cursor
+                : `${input.folder_ref
+                    ? `/me/drive/items/${encodeURIComponent(input.folder_ref)}/children`
+                    : "/me/drive/root/children"}?$top=${input.limit ?? 100}&$select=${ITEM_SELECT}`;
+            const data = await graphJson(ctx, path);
+            return {
+                entries: (data.value ?? []).map(toCapabilityEntry),
+                next_cursor: nextLinkToCursor(data["@odata.nextLink"]),
+            };
+        },
+        async read(ctx, input) {
+            const encodedId = encodeURIComponent(input.file_ref);
+            const item = await graphJson(ctx, `/me/drive/items/${encodedId}?$select=${ITEM_SELECT}`);
+            if (item.folder) {
+                throw new Error("onedrive_read: item is a folder");
+            }
+            const cap = input.max_bytes ?? 20_000_000;
+            if ((item.size ?? 0) > cap) {
+                throw new Error(`onedrive_file_too_large: ${item.size} bytes exceeds the ${cap} byte cap`);
+            }
+            // /content 302-redirects to a pre-authenticated download URL; fetch
+            // follows it transparently.
+            const res = await graphRaw(ctx, `/me/drive/items/${encodedId}/content`);
+            const mimeType = item.file?.mimeType ?? "application/octet-stream";
+            if (isTextishMimeType(mimeType)) {
+                const content = await res.text();
+                return {
+                    content,
+                    kind: "text",
+                    mime_type: mimeType,
+                    name: item.name ?? null,
+                    size: item.size ?? content.length,
+                    truncated: false,
+                };
+            }
+            const buffer = new Uint8Array(await res.arrayBuffer());
+            return {
+                content_base64: Buffer.from(buffer).toString("base64"),
+                kind: "base64",
+                mime_type: mimeType,
+                name: item.name ?? null,
+                size: item.size ?? buffer.byteLength,
+                truncated: false,
+            };
+        },
+        async search(ctx, input) {
+            const q = encodeURIComponent(input.query.replace(/'/g, "''"));
+            const base = input.folder_ref
+                ? `/me/drive/items/${encodeURIComponent(input.folder_ref)}`
+                : "/me/drive/root";
+            const data = await graphJson(ctx, `${base}/search(q='${q}')?$top=${input.limit ?? 100}&$select=${ITEM_SELECT}`);
+            return {
+                entries: (data.value ?? []).map(toCapabilityEntry),
+                next_cursor: null,
+            };
+        },
+        async stat(ctx, input) {
+            const item = await graphJson(ctx, `/me/drive/items/${encodeURIComponent(input.ref)}?$select=${ITEM_SELECT}`);
+            return toCapabilityEntry(item);
+        },
+    },
+    filesProviderScopes: ["Files.Read"],
+    icon: "logo:microsoft-onedrive",
+    id: "microsoft-onedrive",
+    moduleId: "connections-microsoft",
+    name: "Microsoft OneDrive",
+    toolPrefix: "onedrive",
+});