@jitsusama/agentic-harness.core 0.1.0

package/dist/google/apis/drive.js

@@ -0,0 +1,189 @@
+/**
+ * Google Drive API client.
+ */
+import { google } from "googleapis";
+/**
+ * List Drive files with optional filtering.
+ */
+export async function listFiles(auth, options = {}) {
+    const drive = google.drive({ version: "v3", auth });
+    // We build the query parts.
+    const queryParts = ["trashed = false"];
+    if (options.folderId) {
+        queryParts.push(`'${options.folderId}' in parents`);
+    }
+    if (options.query) {
+        queryParts.push(`fullText contains '${options.query}'`);
+    }
+    if (options.type) {
+        const mimeType = getMimeType(options.type);
+        if (mimeType.endsWith("/")) {
+            queryParts.push(`mimeType contains '${mimeType}'`);
+        }
+        else {
+            queryParts.push(`mimeType = '${mimeType}'`);
+        }
+    }
+    if (options.owner === "me") {
+        queryParts.push("'me' in owners");
+    }
+    else if (options.owner) {
+        queryParts.push(`'${options.owner}' in owners`);
+    }
+    if (options.shared) {
+        queryParts.push("sharedWithMe = true");
+    }
+    if (options.modifiedAfter) {
+        queryParts.push(`modifiedTime > '${toRfc3339(options.modifiedAfter)}'`);
+    }
+    if (options.modifiedBefore) {
+        queryParts.push(`modifiedTime < '${toRfc3339(options.modifiedBefore)}'`);
+    }
+    const q = queryParts.join(" and ");
+    const orderBy = options.orderBy
+        ? options.orderBy === "relevance"
+            ? undefined
+            : `${options.orderBy} desc`
+        : "modifiedTime desc";
+    const response = await drive.files.list({
+        q,
+        pageSize: options.limit || 25,
+        orderBy,
+        pageToken: options.pageToken,
+        fields: "files(id,name,mimeType,size,modifiedTime,owners,webViewLink,iconLink),nextPageToken",
+        ...(options.sharedDriveId
+            ? {
+                driveId: options.sharedDriveId,
+                includeItemsFromAllDrives: true,
+                supportsAllDrives: true,
+            }
+            : {}),
+    });
+    const files = (response.data.files || []).map((f) => ({
+        id: f.id || "",
+        name: f.name || "",
+        mimeType: f.mimeType || "",
+        size: f.size ? Number.parseInt(f.size, 10) : undefined,
+        modifiedTime: f.modifiedTime || "",
+        owners: (f.owners || []).map((o) => ({
+            displayName: o.displayName || "",
+            emailAddress: o.emailAddress || "",
+        })),
+        webViewLink: f.webViewLink || undefined,
+        iconLink: f.iconLink || undefined,
+    }));
+    return {
+        files,
+        nextPageToken: response.data.nextPageToken || undefined,
+    };
+}
+/**
+ * Get file metadata.
+ */
+export async function getFileMetadata(auth, fileId) {
+    const drive = google.drive({ version: "v3", auth });
+    const response = await drive.files.get({
+        fileId,
+        fields: "id,name,mimeType,size,modifiedTime,createdTime,owners,webViewLink,iconLink,description",
+        supportsAllDrives: true,
+    });
+    const f = response.data;
+    return {
+        id: f.id || "",
+        name: f.name || "",
+        mimeType: f.mimeType || "",
+        size: f.size ? Number.parseInt(f.size, 10) : undefined,
+        modifiedTime: f.modifiedTime || "",
+        owners: (f.owners || []).map((o) => ({
+            displayName: o.displayName || "",
+            emailAddress: o.emailAddress || "",
+        })),
+        webViewLink: f.webViewLink || undefined,
+        iconLink: f.iconLink || undefined,
+    };
+}
+/**
+ * List shared drives accessible to the user.
+ */
+export async function listSharedDrives(auth) {
+    const drive = google.drive({ version: "v3", auth });
+    const response = await drive.drives.list({
+        pageSize: 100,
+        fields: "drives(id,name)",
+    });
+    return (response.data.drives || []).map((d) => ({
+        id: d.id || "",
+        name: d.name || "",
+    }));
+}
+/**
+ * Parse file ID (and optional tab ID) from a Google URL.
+ */
+export function parseGoogleUrl(url) {
+    // We match against various Google URL patterns.
+    const patterns = [
+        // docs.google.com/document/d/FILE_ID/...
+        /docs\.google\.com\/document\/d\/([a-zA-Z0-9_-]+)/,
+        // docs.google.com/spreadsheets/d/FILE_ID/...
+        /docs\.google\.com\/spreadsheets\/d\/([a-zA-Z0-9_-]+)/,
+        // docs.google.com/presentation/d/FILE_ID/...
+        /docs\.google\.com\/presentation\/d\/([a-zA-Z0-9_-]+)/,
+        // drive.google.com/file/d/FILE_ID/...
+        /drive\.google\.com\/file\/d\/([a-zA-Z0-9_-]+)/,
+        // drive.google.com/open?id=FILE_ID
+        /drive\.google\.com\/open\?id=([a-zA-Z0-9_-]+)/,
+    ];
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match?.[1]) {
+            let type = "file";
+            if (url.includes("/document/"))
+                type = "doc";
+            else if (url.includes("/spreadsheets/"))
+                type = "sheet";
+            else if (url.includes("/presentation/"))
+                type = "slides";
+            const tabId = extractTabId(url);
+            return { id: match[1], type, ...(tabId ? { tabId } : {}) };
+        }
+    }
+    return null;
+}
+/**
+ * Extract a tab ID from a Google Docs URL query parameter.
+ * Google Docs tab links use `?tab=t.XXXXX` or `#tab=t.XXXXX`.
+ */
+function extractTabId(url) {
+    const match = url.match(/[?&#]tab=(t\.[a-zA-Z0-9_-]+)/);
+    return match?.[1];
+}
+function getMimeType(type) {
+    const mimeTypes = {
+        doc: "application/vnd.google-apps.document",
+        document: "application/vnd.google-apps.document",
+        sheet: "application/vnd.google-apps.spreadsheet",
+        spreadsheet: "application/vnd.google-apps.spreadsheet",
+        slides: "application/vnd.google-apps.presentation",
+        presentation: "application/vnd.google-apps.presentation",
+        folder: "application/vnd.google-apps.folder",
+        pdf: "application/pdf",
+        image: "image/",
+        video: "video/",
+    };
+    return mimeTypes[type] || type;
+}
+/**
+ * Convert a date string to RFC 3339 format for Drive
+ * queries. Accepts YYYY-MM-DD or full ISO 8601.
+ */
+function toRfc3339(date) {
+    // Already a full timestamp.
+    if (date.includes("T"))
+        return date;
+    // Date-only: append midnight UTC.
+    if (/^\d{4}-\d{2}-\d{2}$/.test(date))
+        return `${date}T00:00:00Z`;
+    // Unrecognised format: pass through and let the API
+    // reject it rather than silently mangling the value.
+    return date;
+}

package/dist/google/apis/gmail.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Gmail API client.
+ */
+import type { OAuth2Client } from "google-auth-library";
+import type { EmailMessage, EmailMessageFull } from "../types.js";
+/**
+ * Search emails using Gmail query syntax.
+ */
+export declare function searchEmails(auth: OAuth2Client, query: string, limit?: number, pageToken?: string): Promise<{
+    messages: EmailMessage[];
+    nextPageToken?: string;
+}>;
+/**
+ * Get a single email by ID.
+ */
+export declare function getEmail(auth: OAuth2Client, messageId: string, format?: "full" | "metadata" | "minimal"): Promise<EmailMessageFull>;
+/**
+ * Get an email thread.
+ */
+export declare function getThread(auth: OAuth2Client, messageId: string): Promise<EmailMessageFull[]>;
+/**
+ * Send an email.
+ */
+export declare function sendEmail(auth: OAuth2Client, options: {
+    to: string[];
+    subject: string;
+    body: string;
+    cc?: string[];
+    bcc?: string[];
+    replyTo?: string;
+}): Promise<{
+    id: string;
+    threadId: string;
+}>;
+/**
+ * Create a draft email.
+ */
+export declare function createDraft(auth: OAuth2Client, options: {
+    to: string[];
+    subject: string;
+    body: string;
+    cc?: string[];
+    bcc?: string[];
+}): Promise<{
+    id: string;
+    messageId: string;
+}>;
+/**
+ * Archive an email (remove INBOX label).
+ */
+export declare function archiveEmail(auth: OAuth2Client, messageId: string): Promise<void>;
+/**
+ * Unarchive an email (add INBOX label back).
+ */
+export declare function unarchiveEmail(auth: OAuth2Client, messageId: string): Promise<void>;
+/**
+ * Delete an email (move to trash).
+ */
+export declare function deleteEmail(auth: OAuth2Client, messageId: string): Promise<void>;
+/**
+ * Mark an email as read.
+ */
+export declare function markRead(auth: OAuth2Client, messageId: string): Promise<void>;
+/**
+ * Mark an email as unread.
+ */
+export declare function markUnread(auth: OAuth2Client, messageId: string): Promise<void>;

package/dist/google/apis/gmail.js

@@ -0,0 +1,374 @@
+/**
+ * Gmail API client.
+ */
+import { google } from "googleapis";
+/**
+ * Search emails using Gmail query syntax.
+ */
+export async function searchEmails(auth, query, limit = 25, pageToken) {
+    const gmail = google.gmail({ version: "v1", auth });
+    const listResponse = await gmail.users.messages.list({
+        userId: "me",
+        q: query,
+        maxResults: limit,
+        pageToken,
+    });
+    const messageIds = listResponse.data.messages || [];
+    if (messageIds.length === 0) {
+        return { messages: [] };
+    }
+    // We fetch metadata for each message.
+    const messages = [];
+    for (const { id } of messageIds) {
+        if (!id)
+            continue;
+        const msg = await gmail.users.messages.get({
+            userId: "me",
+            id,
+            format: "metadata",
+            metadataHeaders: ["From", "To", "Cc", "Subject", "Date"],
+        });
+        const headers = msg.data.payload?.headers || [];
+        const getHeader = (name) => headers.find((h) => h.name?.toLowerCase() === name.toLowerCase())
+            ?.value || "";
+        messages.push({
+            id: msg.data.id || "",
+            threadId: msg.data.threadId || "",
+            subject: getHeader("Subject") || "(no subject)",
+            from: parseEmailAddress(getHeader("From")),
+            to: parseEmailAddresses(getHeader("To")),
+            cc: getHeader("Cc") ? parseEmailAddresses(getHeader("Cc")) : undefined,
+            date: getHeader("Date"),
+            snippet: msg.data.snippet || "",
+            labels: msg.data.labelIds || [],
+            hasAttachments: hasAttachments(msg.data.payload),
+        });
+    }
+    return {
+        messages,
+        nextPageToken: listResponse.data.nextPageToken || undefined,
+    };
+}
+/**
+ * Get a single email by ID.
+ */
+export async function getEmail(auth, messageId, format = "full") {
+    const gmail = google.gmail({ version: "v1", auth });
+    const msg = await gmail.users.messages.get({
+        userId: "me",
+        id: messageId,
+        format,
+    });
+    const headers = msg.data.payload?.headers || [];
+    const getHeader = (name) => headers.find((h) => h.name?.toLowerCase() === name.toLowerCase())?.value ||
+        "";
+    const message = {
+        id: msg.data.id || "",
+        threadId: msg.data.threadId || "",
+        subject: getHeader("Subject") || "(no subject)",
+        from: parseEmailAddress(getHeader("From")),
+        to: parseEmailAddresses(getHeader("To")),
+        cc: getHeader("Cc") ? parseEmailAddresses(getHeader("Cc")) : undefined,
+        date: getHeader("Date"),
+        snippet: msg.data.snippet || "",
+        labels: msg.data.labelIds || [],
+        hasAttachments: hasAttachments(msg.data.payload),
+        body: extractBody(msg.data.payload),
+        attachments: extractAttachments(msg.data.payload),
+    };
+    return message;
+}
+/**
+ * Get an email thread.
+ */
+export async function getThread(auth, messageId) {
+    const gmail = google.gmail({ version: "v1", auth });
+    // We first get the message to find its thread ID.
+    const msg = await gmail.users.messages.get({
+        userId: "me",
+        id: messageId,
+        format: "minimal",
+    });
+    const threadId = msg.data.threadId;
+    if (!threadId) {
+        throw new Error("Message has no thread ID");
+    }
+    // We get the full thread.
+    const thread = await gmail.users.threads.get({
+        userId: "me",
+        id: threadId,
+        format: "full",
+    });
+    const messages = [];
+    for (const msgData of thread.data.messages || []) {
+        const headers = msgData.payload?.headers || [];
+        const getHeader = (name) => headers.find((h) => h.name?.toLowerCase() === name.toLowerCase())
+            ?.value || "";
+        messages.push({
+            id: msgData.id || "",
+            threadId: msgData.threadId || "",
+            subject: getHeader("Subject") || "(no subject)",
+            from: parseEmailAddress(getHeader("From")),
+            to: parseEmailAddresses(getHeader("To")),
+            cc: getHeader("Cc") ? parseEmailAddresses(getHeader("Cc")) : undefined,
+            date: getHeader("Date"),
+            snippet: msgData.snippet || "",
+            labels: msgData.labelIds || [],
+            hasAttachments: hasAttachments(msgData.payload),
+            body: extractBody(msgData.payload),
+            attachments: extractAttachments(msgData.payload),
+        });
+    }
+    return messages;
+}
+/**
+ * Send an email.
+ */
+export async function sendEmail(auth, options) {
+    const gmail = google.gmail({ version: "v1", auth });
+    // We build the email message.
+    const headers = [
+        `To: ${options.to.join(", ")}`,
+        ...(options.cc ? [`Cc: ${options.cc.join(", ")}`] : []),
+        ...(options.bcc ? [`Bcc: ${options.bcc.join(", ")}`] : []),
+        `Subject: ${options.subject}`,
+    ];
+    // If replying, we add headers and fetch the original message.
+    let threadId;
+    if (options.replyTo) {
+        const original = await gmail.users.messages.get({
+            userId: "me",
+            id: options.replyTo,
+            format: "metadata",
+            metadataHeaders: ["Message-ID", "References"],
+        });
+        const messageIdHeader = original.data.payload?.headers?.find((h) => h.name?.toLowerCase() === "message-id")?.value;
+        const referencesHeader = original.data.payload?.headers?.find((h) => h.name?.toLowerCase() === "references")?.value;
+        if (messageIdHeader) {
+            headers.push(`In-Reply-To: ${messageIdHeader}`);
+            headers.push(`References: ${referencesHeader ? `${referencesHeader} ` : ""}${messageIdHeader}`);
+        }
+        threadId = original.data.threadId || undefined;
+    }
+    const message = [...headers, "", options.body].join("\n");
+    // We encode the message.
+    const encodedMessage = Buffer.from(message)
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+    const result = await gmail.users.messages.send({
+        userId: "me",
+        requestBody: {
+            raw: encodedMessage,
+            threadId,
+        },
+    });
+    return {
+        id: result.data.id || "",
+        threadId: result.data.threadId || "",
+    };
+}
+/**
+ * Create a draft email.
+ */
+export async function createDraft(auth, options) {
+    const gmail = google.gmail({ version: "v1", auth });
+    const headers = [
+        `To: ${options.to.join(", ")}`,
+        ...(options.cc ? [`Cc: ${options.cc.join(", ")}`] : []),
+        ...(options.bcc ? [`Bcc: ${options.bcc.join(", ")}`] : []),
+        `Subject: ${options.subject}`,
+    ];
+    const message = [...headers, "", options.body].join("\n");
+    const encodedMessage = Buffer.from(message)
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+    const result = await gmail.users.drafts.create({
+        userId: "me",
+        requestBody: {
+            message: {
+                raw: encodedMessage,
+            },
+        },
+    });
+    return {
+        id: result.data.id || "",
+        messageId: result.data.message?.id || "",
+    };
+}
+/**
+ * Archive an email (remove INBOX label).
+ */
+export async function archiveEmail(auth, messageId) {
+    const gmail = google.gmail({ version: "v1", auth });
+    await gmail.users.messages.modify({
+        userId: "me",
+        id: messageId,
+        requestBody: {
+            removeLabelIds: ["INBOX"],
+        },
+    });
+}
+/**
+ * Unarchive an email (add INBOX label back).
+ */
+export async function unarchiveEmail(auth, messageId) {
+    const gmail = google.gmail({ version: "v1", auth });
+    await gmail.users.messages.modify({
+        userId: "me",
+        id: messageId,
+        requestBody: {
+            addLabelIds: ["INBOX"],
+        },
+    });
+}
+/**
+ * Delete an email (move to trash).
+ */
+export async function deleteEmail(auth, messageId) {
+    const gmail = google.gmail({ version: "v1", auth });
+    await gmail.users.messages.trash({
+        userId: "me",
+        id: messageId,
+    });
+}
+/**
+ * Mark an email as read.
+ */
+export async function markRead(auth, messageId) {
+    const gmail = google.gmail({ version: "v1", auth });
+    await gmail.users.messages.modify({
+        userId: "me",
+        id: messageId,
+        requestBody: {
+            removeLabelIds: ["UNREAD"],
+        },
+    });
+}
+/**
+ * Mark an email as unread.
+ */
+export async function markUnread(auth, messageId) {
+    const gmail = google.gmail({ version: "v1", auth });
+    await gmail.users.messages.modify({
+        userId: "me",
+        id: messageId,
+        requestBody: {
+            addLabelIds: ["UNREAD"],
+        },
+    });
+}
+function parseEmailAddress(header) {
+    const match = header.match(/^(.*?)\s*<(.+?)>$/);
+    if (match) {
+        return {
+            name: match[1]?.trim().replace(/^["']|["']$/g, "") || "",
+            email: match[2]?.trim() || "",
+        };
+    }
+    return { name: "", email: header.trim() };
+}
+function parseEmailAddresses(header) {
+    if (!header)
+        return [];
+    return header.split(",").map((addr) => parseEmailAddress(addr.trim()));
+}
+function hasAttachments(payload) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const parts = payload.parts;
+    if (!parts)
+        return false;
+    return parts.some((part) => {
+        if (typeof part === "object" &&
+            part !== null &&
+            "filename" in part &&
+            part.filename) {
+            return true;
+        }
+        return false;
+    });
+}
+function extractBody(payload) {
+    if (!payload || typeof payload !== "object")
+        return "";
+    const p = payload;
+    // If there's a body.data, we decode it.
+    if (p.body?.data) {
+        return decodeBase64(p.body.data);
+    }
+    // If there are parts, we recursively search for text/plain or text/html.
+    if (p.parts) {
+        for (const part of p.parts) {
+            if (typeof part !== "object" || part === null)
+                continue;
+            const partObj = part;
+            if (partObj.mimeType === "text/plain" && partObj.body?.data) {
+                return decodeBase64(partObj.body.data);
+            }
+        }
+        // We fall back to HTML if there's no plain text.
+        for (const part of p.parts) {
+            if (typeof part !== "object" || part === null)
+                continue;
+            const partObj = part;
+            if (partObj.mimeType === "text/html" && partObj.body?.data) {
+                return stripHtml(decodeBase64(partObj.body.data));
+            }
+        }
+        // We recurse into multipart parts.
+        for (const part of p.parts) {
+            const body = extractBody(part);
+            if (body)
+                return body;
+        }
+    }
+    return "";
+}
+function extractAttachments(payload) {
+    if (!payload || typeof payload !== "object")
+        return [];
+    const attachments = [];
+    const p = payload;
+    if (!p.parts)
+        return [];
+    for (const part of p.parts) {
+        if (typeof part !== "object" || part === null)
+            continue;
+        const partObj = part;
+        if (partObj.filename) {
+            attachments.push({
+                filename: partObj.filename,
+                mimeType: partObj.mimeType || "application/octet-stream",
+                size: partObj.body?.size || 0,
+            });
+        }
+    }
+    return attachments;
+}
+function decodeBase64(data) {
+    try {
+        // Gmail uses URL-safe base64.
+        const base64 = data.replace(/-/g, "+").replace(/_/g, "/");
+        return Buffer.from(base64, "base64").toString("utf-8");
+    }
+    catch (_error) {
+        // Base64 decoding failed (malformed data), so we return an empty string.
+        return "";
+    }
+}
+function stripHtml(html) {
+    // This is very basic HTML stripping: we just remove the tags.
+    return html
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .replace(/&quot;/g, '"')
+        .trim();
+}

package/dist/google/apis/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Google Workspace API clients: Calendar, Docs, Drive,
+ * Gmail, Sheets and Slides.
+ */
+export { createEvent, deleteEvent, getEvent, listEvents, queryFreeBusy, respondToEvent, updateEvent, } from "./calendar.js";
+export { type DocContent, type DocTab, getDocComments, getDocContent, } from "./docs.js";
+export { getFileMetadata, listFiles, listSharedDrives, type ParsedGoogleUrl, parseGoogleUrl, } from "./drive.js";
+export { archiveEmail, createDraft, deleteEmail, getEmail, getThread, markRead, markUnread, searchEmails, sendEmail, unarchiveEmail, } from "./gmail.js";
+export { getSheetContent, type SheetData } from "./sheets.js";
+export { getSlideContent, type SlideData } from "./slides.js";

package/dist/google/apis/index.js

@@ -0,0 +1,10 @@
+/**
+ * Google Workspace API clients: Calendar, Docs, Drive,
+ * Gmail, Sheets and Slides.
+ */
+export { createEvent, deleteEvent, getEvent, listEvents, queryFreeBusy, respondToEvent, updateEvent, } from "./calendar.js";
+export { getDocComments, getDocContent, } from "./docs.js";
+export { getFileMetadata, listFiles, listSharedDrives, parseGoogleUrl, } from "./drive.js";
+export { archiveEmail, createDraft, deleteEmail, getEmail, getThread, markRead, markUnread, searchEmails, sendEmail, unarchiveEmail, } from "./gmail.js";
+export { getSheetContent } from "./sheets.js";
+export { getSlideContent } from "./slides.js";

package/dist/google/apis/sheets.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Google Sheets API client.
+ */
+import type { OAuth2Client } from "google-auth-library";
+/** Extracted content from a Google Sheets spreadsheet. */
+export interface SheetData {
+    title: string;
+    sheets: Array<{
+        name: string;
+        rows: string[][];
+    }>;
+}
+/**
+ * Get spreadsheet content.
+ */
+export declare function getSheetContent(auth: OAuth2Client, spreadsheetId: string): Promise<SheetData>;