@credal/actions 0.2.48 → 0.2.50

package/dist/actions/providers/linear/getTeamDetails.js

@@ -0,0 +1,84 @@
+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());
+    });
+};
+const getTeamDetails = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b;
+    const { authToken } = authParams;
+    const { teamId } = params;
+    if (!authToken) {
+        throw new Error("Valid auth token is required to get Linear team details");
+    }
+    const query = `
+    query GetTeam($id: String!) {
+      team(id: $id) {
+        id
+        name
+        key
+        members {
+          nodes {
+            id
+            name
+            email
+          }
+        }
+      }
+    }
+  `;
+    try {
+        const response = yield fetch("https://api.linear.app/graphql", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${authToken}`,
+            },
+            body: JSON.stringify({
+                query,
+                variables: { id: teamId },
+            }),
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`HTTP error, status: ${response.status} body: ${errorText}`);
+        }
+        const data = yield response.json();
+        if (data.errors) {
+            throw new Error(`GraphQL errors: ${JSON.stringify(data.errors)}`);
+        }
+        if (!((_b = data.data) === null || _b === void 0 ? void 0 : _b.team)) {
+            return {
+                success: false,
+                error: "Team not found",
+            };
+        }
+        const { id, name, key, members } = data.data.team;
+        return {
+            success: true,
+            team: {
+                id,
+                name,
+                identifier: key,
+                members: Array.isArray(members === null || members === void 0 ? void 0 : members.nodes)
+                    ? members.nodes.map(({ id, name, email }) => ({
+                        id,
+                        name,
+                        email,
+                    }))
+                    : [],
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error retrieving Linear team details: ", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default getTeamDetails;

package/dist/actions/providers/linear/getTeams.d.ts

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

package/dist/actions/providers/linear/getTeams.js

@@ -0,0 +1,68 @@
+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());
+    });
+};
+const getTeams = (_a) => __awaiter(void 0, [_a], void 0, function* ({ authParams, }) {
+    var _b;
+    const { authToken } = authParams;
+    if (!authToken) {
+        throw new Error("Valid auth token is required to get Linear teams");
+    }
+    const query = `
+    query GetTeams {
+      teams {
+        nodes {
+          id
+          name
+        }
+      }
+    }
+  `;
+    try {
+        const response = yield fetch("https://api.linear.app/graphql", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${authToken}`,
+            },
+            body: JSON.stringify({
+                query,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = yield response.json();
+        if (data.errors) {
+            throw new Error(`GraphQL errors: ${JSON.stringify(data.errors)}`);
+        }
+        if (!((_b = data.data) === null || _b === void 0 ? void 0 : _b.teams)) {
+            return {
+                success: false,
+                error: "No teams found",
+            };
+        }
+        const { nodes } = data.data.teams;
+        const teams = Array.isArray(nodes) ? nodes : [];
+        return {
+            success: true,
+            teams: teams.map((team) => ({
+                id: team.id,
+                name: team.name,
+            })),
+        };
+    }
+    catch (error) {
+        console.error("Error retrieving Linear teams: ", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default getTeams;

package/dist/actions/providers/snowflake/runSnowflakeQueryWriteResultsToS3.d.ts

@@ -0,0 +1,3 @@
+import { snowflakeRunSnowflakeQueryWriteResultsToS3Function } from "../../autogen/types";
+declare const runSnowflakeQueryWriteResultsToS3: snowflakeRunSnowflakeQueryWriteResultsToS3Function;
+export default runSnowflakeQueryWriteResultsToS3;

package/dist/actions/providers/snowflake/runSnowflakeQueryWriteResultsToS3.js

@@ -0,0 +1,154 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const snowflake_sdk_1 = __importDefault(require("snowflake-sdk"));
+const crypto_1 = __importDefault(require("crypto"));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const uuid_1 = require("uuid");
+// Only log errors.
+snowflake_sdk_1.default.configure({ logLevel: "ERROR" });
+const runSnowflakeQueryWriteResultsToS3 = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const { databaseName, warehouse, query, user, accountName, s3BucketName, s3Region, outputFormat = "json" } = params;
+    const { apiKey: privateKey, awsAccessKeyId, awsSecretAccessKey } = authParams;
+    if (!privateKey) {
+        throw new Error("Snowflake private key is required");
+    }
+    if (!awsAccessKeyId || !awsSecretAccessKey) {
+        throw new Error("AWS credentials are required");
+    }
+    if (!accountName || !user || !databaseName || !warehouse || !query || !s3BucketName) {
+        throw new Error("Missing required parameters for Snowflake query or S3 destination");
+    }
+    const getPrivateKeyCorrectFormat = (privateKey) => {
+        const buffer = Buffer.from(privateKey);
+        const privateKeyObject = crypto_1.default.createPrivateKey({
+            key: buffer,
+            format: "pem",
+            passphrase: "password",
+        });
+        const privateKeyCorrectFormat = privateKeyObject.export({
+            format: "pem",
+            type: "pkcs8",
+        });
+        return privateKeyCorrectFormat.toString();
+    };
+    const executeQueryAndFormatData = () => __awaiter(void 0, void 0, void 0, function* () {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const queryResults = yield new Promise((resolve, reject) => {
+            connection.execute({
+                sqlText: query,
+                complete: (err, stmt, rows) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    return resolve(rows || []);
+                },
+            });
+        });
+        // Format the results based on the output format
+        let formattedData;
+        if (outputFormat.toLowerCase() === "csv") {
+            if (queryResults.length === 0) {
+                formattedData = "";
+            }
+            else {
+                const headers = Object.keys(queryResults[0]).join(",");
+                const rows = queryResults.map(row => Object.values(row)
+                    .map(value => (typeof value === "object" && value !== null ? JSON.stringify(value) : value))
+                    .join(","));
+                formattedData = [headers, ...rows].join("\n");
+            }
+        }
+        else {
+            // Default to JSON
+            formattedData = JSON.stringify(queryResults, null, 2);
+        }
+        return { formattedData, resultsLength: queryResults.length };
+    });
+    const uploadToS3AndGetURL = (formattedData) => __awaiter(void 0, void 0, void 0, function* () {
+        // Create S3 client
+        const s3Client = new client_s3_1.S3Client({
+            region: s3Region,
+            credentials: {
+                accessKeyId: awsAccessKeyId,
+                secretAccessKey: awsSecretAccessKey,
+            },
+        });
+        const contentType = outputFormat.toLowerCase() === "csv" ? "text/csv" : "application/json";
+        const fileExtension = outputFormat.toLowerCase() === "csv" ? "csv" : "json";
+        const finalKey = `${databaseName}/${(0, uuid_1.v4)()}.${fileExtension}`;
+        // Upload to S3 without ACL
+        const uploadCommand = new client_s3_1.PutObjectCommand({
+            Bucket: s3BucketName,
+            Key: finalKey,
+            Body: formattedData,
+            ContentType: contentType,
+        });
+        yield s3Client.send(uploadCommand);
+        // Generate a presigned URL (valid for an hour)
+        const getObjectCommand = new client_s3_1.GetObjectCommand({
+            Bucket: s3BucketName,
+            Key: finalKey,
+        });
+        const presignedUrl = yield (0, s3_request_presigner_1.getSignedUrl)(s3Client, getObjectCommand, { expiresIn: 3600 });
+        return presignedUrl;
+    });
+    // Process the private key
+    const privateKeyCorrectFormatString = getPrivateKeyCorrectFormat(privateKey);
+    // Set up a connection using snowflake-sdk
+    const connection = snowflake_sdk_1.default.createConnection({
+        account: accountName,
+        username: user,
+        privateKey: privateKeyCorrectFormatString,
+        authenticator: "SNOWFLAKE_JWT",
+        role: "ACCOUNTADMIN",
+        warehouse: warehouse,
+        database: databaseName,
+    });
+    try {
+        // Connect to Snowflake
+        yield new Promise((resolve, reject) => {
+            connection.connect((err, conn) => {
+                if (err) {
+                    console.error("Unable to connect to Snowflake:", err.message);
+                    return reject(err);
+                }
+                resolve(conn);
+            });
+        });
+        const { formattedData, resultsLength } = yield executeQueryAndFormatData();
+        const presignedUrl = yield uploadToS3AndGetURL(formattedData);
+        // Return fields to match schema definition
+        connection.destroy(err => {
+            if (err) {
+                console.log("Failed to disconnect from Snowflake:", err);
+            }
+        });
+        return {
+            bucketUrl: presignedUrl,
+            message: `Query results successfully written to S3. URL valid for 1 hour.`,
+            rowCount: resultsLength,
+        };
+    }
+    catch (error) {
+        connection.destroy(err => {
+            if (err) {
+                console.log("Failed to disconnect from Snowflake:", err);
+            }
+        });
+        throw Error(`An error occurred: ${error}`);
+    }
+});
+exports.default = runSnowflakeQueryWriteResultsToS3;

package/dist/actions/providers/x/scrapeTweetDataWithNitter.d.ts

@@ -0,0 +1,3 @@
+import { xScrapePostDataWithNitterFunction } from "../../autogen/types";
+declare const scrapeTweetDataWithNitter: xScrapePostDataWithNitterFunction;
+export default scrapeTweetDataWithNitter;

package/dist/actions/providers/x/scrapeTweetDataWithNitter.js

@@ -0,0 +1,45 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const firecrawl_js_1 = __importDefault(require("@mendable/firecrawl-js"));
+const scrapeTweetDataWithNitter = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    const tweetUrlRegex = /^(?:https?:\/\/)?(?:www\.)?(?:twitter\.com|x\.com)\/([a-zA-Z0-9_]+)\/status\/(\d+)(?:\?.*)?$/;
+    if (!tweetUrlRegex.test(params.tweetUrl)) {
+        throw new Error("Invalid tweet URL. Expected format: https://twitter.com/username/status/id or https://x.com/username/status/id");
+    }
+    const nitterUrl = params.tweetUrl.replace(/^(?:https?:\/\/)?(?:www\.)?(?:twitter\.com|x\.com)/i, "https://nitter.net");
+    // Initialize Firecrawl
+    if (!authParams.apiKey) {
+        throw new Error("API key is required for X+Nitter+Firecrawl");
+    }
+    const firecrawl = new firecrawl_js_1.default({
+        apiKey: authParams.apiKey,
+    });
+    try {
+        // Scrape the Nitter URL
+        const result = yield firecrawl.scrapeUrl(nitterUrl);
+        if (!result.success) {
+            throw new Error(`Failed to scrape tweet: ${result.error || "Unknown error"}`);
+        }
+        // Extract the tweet text from the scraped content - simple approach - in practice, you might need more robust parsing based on nitter html structure
+        const tweetContent = result.markdown;
+        return {
+            text: tweetContent || "Error scraping with firecrawl",
+        };
+    }
+    catch (error) {
+        throw new Error(`Error scraping tweet: ${error instanceof Error ? error.message : error}`);
+    }
+});
+exports.default = scrapeTweetDataWithNitter;

package/dist/utils/google.d.ts

@@ -0,0 +1,4 @@
+import type { docs_v1, sheets_v4, slides_v1 } from "googleapis";
+export declare function parseGoogleDocFromRawContentToPlainText(snapshotRawContent: docs_v1.Schema$Document): string;
+export declare function parseGoogleSheetsFromRawContentToPlainText(snapshotRawContent: sheets_v4.Schema$Spreadsheet): string;
+export declare function parseGoogleSlidesFromRawContentToPlainText(snapshotRawContent: slides_v1.Schema$Presentation): string;

package/dist/utils/google.js

@@ -0,0 +1,170 @@
+// Helper function to parse Google Docs content to plain text
+export function parseGoogleDocFromRawContentToPlainText(snapshotRawContent) {
+    var _a, _b, _c, _d, _e, _f;
+    const docSections = [
+        {
+            heading: undefined,
+            paragraphs: [],
+        },
+    ];
+    if (!((_a = snapshotRawContent.body) === null || _a === void 0 ? void 0 : _a.content))
+        return "";
+    for (const content of snapshotRawContent.body.content) {
+        if (!content)
+            continue;
+        // Handle paragraphs (existing logic)
+        if (content.paragraph) {
+            const paragraph = content.paragraph;
+            if ((_b = paragraph.paragraphStyle) === null || _b === void 0 ? void 0 : _b.headingId) {
+                // New heading
+                docSections.push({
+                    heading: {
+                        id: paragraph.paragraphStyle.headingId,
+                        type: paragraph.paragraphStyle.namedStyleType || "",
+                    },
+                    paragraphs: [],
+                });
+            }
+            if (paragraph === null || paragraph === void 0 ? void 0 : paragraph.elements) {
+                const combinedTextRuns = paragraph.elements
+                    .map(element => { var _a; return (_a = element.textRun) === null || _a === void 0 ? void 0 : _a.content; })
+                    .filter((content) => Boolean(content))
+                    .join("");
+                const bulletNestingLevel = paragraph.bullet === undefined ? undefined : ((_d = (_c = paragraph.bullet) === null || _c === void 0 ? void 0 : _c.nestingLevel) !== null && _d !== void 0 ? _d : 0);
+                const paragraphContent = bulletNestingLevel === undefined
+                    ? combinedTextRuns
+                    : "\t".repeat(bulletNestingLevel) + " • " + combinedTextRuns;
+                docSections[docSections.length - 1].paragraphs.push(paragraphContent);
+            }
+        }
+        // Handle tables
+        if (content.table) {
+            const table = content.table;
+            const tableText = [];
+            if (table.tableRows) {
+                for (const row of table.tableRows) {
+                    if (!row.tableCells)
+                        continue;
+                    const cellTexts = [];
+                    for (const cell of row.tableCells) {
+                        if (!cell.content)
+                            continue;
+                        const cellText = [];
+                        for (const cellContent of cell.content) {
+                            if ((_e = cellContent.paragraph) === null || _e === void 0 ? void 0 : _e.elements) {
+                                const cellParagraphText = cellContent.paragraph.elements
+                                    .map(element => { var _a; return (_a = element.textRun) === null || _a === void 0 ? void 0 : _a.content; })
+                                    .filter((content) => Boolean(content))
+                                    .join("");
+                                if (cellParagraphText.trim()) {
+                                    cellText.push(cellParagraphText.trim());
+                                }
+                            }
+                        }
+                        cellTexts.push(cellText.join(" "));
+                    }
+                    if (cellTexts.some(text => text.trim())) {
+                        tableText.push(cellTexts.join(" | "));
+                    }
+                }
+            }
+            if (tableText.length > 0) {
+                docSections[docSections.length - 1].paragraphs.push(tableText.join("\n"));
+            }
+        }
+        // Handle section breaks (just in case they contain text)
+        if (content.sectionBreak) {
+            // Section breaks typically don't contain text, but we'll check anyway
+            // This is mostly for completeness
+            continue;
+        }
+        // Handle table of contents (extract any text)
+        if (content.tableOfContents) {
+            const toc = content.tableOfContents;
+            if (toc.content) {
+                const tocText = [];
+                for (const tocContent of toc.content) {
+                    if ((_f = tocContent.paragraph) === null || _f === void 0 ? void 0 : _f.elements) {
+                        const tocParagraphText = tocContent.paragraph.elements
+                            .map(element => { var _a; return (_a = element.textRun) === null || _a === void 0 ? void 0 : _a.content; })
+                            .filter((content) => Boolean(content))
+                            .join("");
+                        if (tocParagraphText.trim()) {
+                            tocText.push(tocParagraphText.trim());
+                        }
+                    }
+                }
+                if (tocText.length > 0) {
+                    docSections[docSections.length - 1].paragraphs.push(tocText.join("\n"));
+                }
+            }
+        }
+    }
+    const validDocSections = docSections.filter(section => section.heading || section.paragraphs.length > 0);
+    return validDocSections.map(section => section.paragraphs.join(" ")).join("\n");
+}
+export function parseGoogleSheetsFromRawContentToPlainText(snapshotRawContent) {
+    var _a;
+    if (!snapshotRawContent.sheets)
+        return "";
+    const sheetContents = [];
+    for (const sheet of snapshotRawContent.sheets) {
+        if (!sheet.data || !((_a = sheet.properties) === null || _a === void 0 ? void 0 : _a.title))
+            continue;
+        const sheetTitle = sheet.properties.title;
+        const sheetRows = [`Sheet: ${sheetTitle}`];
+        for (const gridData of sheet.data) {
+            if (!gridData.rowData)
+                continue;
+            for (const rowData of gridData.rowData) {
+                if (!rowData.values)
+                    continue;
+                const cellValues = rowData.values
+                    .map(cell => {
+                    var _a, _b, _c;
+                    if (cell.formattedValue)
+                        return cell.formattedValue;
+                    if ((_a = cell.userEnteredValue) === null || _a === void 0 ? void 0 : _a.stringValue)
+                        return cell.userEnteredValue.stringValue;
+                    if ((_b = cell.userEnteredValue) === null || _b === void 0 ? void 0 : _b.numberValue)
+                        return cell.userEnteredValue.numberValue.toString();
+                    if ((_c = cell.userEnteredValue) === null || _c === void 0 ? void 0 : _c.boolValue)
+                        return cell.userEnteredValue.boolValue.toString();
+                    return "";
+                })
+                    .filter(value => value !== "");
+                if (cellValues.length > 0) {
+                    sheetRows.push(cellValues.join(" | "));
+                }
+            }
+        }
+        if (sheetRows.length > 1) {
+            sheetContents.push(sheetRows.join("\n"));
+        }
+    }
+    return sheetContents.join("\n\n");
+}
+export function parseGoogleSlidesFromRawContentToPlainText(snapshotRawContent) {
+    var _a, _b, _c;
+    if (!snapshotRawContent.slides)
+        return "";
+    const slideContents = [];
+    for (const slide of snapshotRawContent.slides) {
+        if (!slide.pageElements)
+            continue;
+        const slideTexts = [];
+        for (const pageElement of slide.pageElements) {
+            if (!((_b = (_a = pageElement.shape) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.textElements))
+                continue;
+            for (const textElement of pageElement.shape.text.textElements) {
+                if ((_c = textElement.textRun) === null || _c === void 0 ? void 0 : _c.content) {
+                    slideTexts.push(textElement.textRun.content.trim());
+                }
+            }
+        }
+        if (slideTexts.length > 0) {
+            slideContents.push(slideTexts.join(" "));
+        }
+    }
+    return slideContents.join("\n\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@credal/actions",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "type": "module",
   "description": "AI Actions by Credal AI",
   "sideEffects": false,
@@ -55,6 +55,7 @@
     "date-fns": "^4.1.0",
     "docx": "^9.3.0",
     "dotenv": "^16.4.7",
+    "googleapis": "^148.0.0",
     "json-schema-to-zod": "^2.5.0",
     "jsonwebtoken": "^9.0.2",
     "mammoth": "^1.4.27",

package/dist/actions/providers/jamf/types.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-export declare const TokenResponseSchema: z.ZodObject<{
-    token: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    token: string;
-}, {
-    token: string;
-}>;

package/dist/actions/providers/jamf/types.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenResponseSchema = void 0;
-const zod_1 = require("zod");
-exports.TokenResponseSchema = zod_1.z.object({
-    token: zod_1.z.string(),
-});