zele 0.2.0 → 0.3.5

package/dist/generated/models/Thread.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Thread.js.map

package/dist/generated/models/Thread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Thread.js","sourceRoot":"","sources":["../../../src/generated/models/Thread.ts"],"names":[],"mappings":""}

package/dist/generated/models.d.ts

@@ -1,10 +1,7 @@
-export type * from './models/accounts.js';
-export type * from './models/thread_lists.js';
-export type * from './models/threads.js';
-export type * from './models/labels.js';
-export type * from './models/label_counts.js';
-export type * from './models/profiles.js';
-export type * from './models/calendar_lists.js';
-export type * from './models/calendar_events.js';
-export type * from './models/sync_states.js';
+export type * from './models/Account.js';
+export type * from './models/Thread.js';
+export type * from './models/Label.js';
+export type * from './models/Profile.js';
+export type * from './models/CalendarList.js';
+export type * from './models/SyncState.js';
 export type * from './commonInputTypes.js';

package/dist/gmail-client.d.ts

@@ -1,5 +1,7 @@
 import { type gmail_v1 } from '@googleapis/gmail';
 import type { OAuth2Client } from 'google-auth-library';
+import { AuthError, ApiError, NotFoundError, EmptyThreadError, MissingDataError } from './api-utils.js';
+import type { AccountId } from './auth.js';
 export interface Sender {
     name?: string;
     email: string;
@@ -25,6 +27,7 @@ export interface ParsedMessage {
     listUnsubscribe?: string;
     body: string;
     mimeType: string;
+    textBody: string | null;
     attachments: AttachmentMeta[];
 }
 export interface AttachmentMeta {
@@ -58,46 +61,60 @@ export interface ThreadListItem {
 }
 export interface ThreadListResult {
     threads: ThreadListItem[];
+    /** Raw Google gmail_v1.Schema$Thread metadata responses, parallel to threads[]. */
+    rawThreads: gmail_v1.Schema$Thread[];
     nextPageToken: string | null;
     resultSizeEstimate: number;
 }
+/** Result from getThread() — includes both parsed data and the raw Google response. */
+export interface ThreadResult {
+    parsed: ThreadData;
+    raw: gmail_v1.Schema$Thread;
+}
+export interface WatchEvent {
+    account: AccountId;
+    type: 'new_message';
+    message: ParsedMessage;
+    threadId: string;
+}
 export declare class GmailClient {
     private gmail;
     private labelIdCache;
-    constructor({ auth }: {
+    private account;
+    constructor({ auth, account }: {
         auth: OAuth2Client;
+        account?: AccountId;
     });
+    private get cacheEnabled();
+    private getCachedThread;
+    private cacheThreadData;
+    invalidateThreads(threadIds: string[]): Promise<void>;
+    invalidateThread(threadId: string): Promise<void>;
+    private getCachedLabels;
+    private cacheLabelsData;
+    invalidateLabels(): Promise<void>;
+    private getCachedProfile;
+    private cacheProfileData;
     listThreads({ query, folder, maxResults, labelIds, pageToken, }?: {
         query?: string;
         folder?: string;
         maxResults?: number;
         labelIds?: string[];
         pageToken?: string;
-    }): Promise<ThreadListResult>;
+    }): Promise<ThreadListResult | AuthError | ApiError>;
     getThread({ threadId }: {
         threadId: string;
-    }): Promise<{
-        id: string;
-        historyId: string | null;
-        messages: ParsedMessage[];
-        subject: string;
-        snippet: string;
-        from: Sender;
-        date: string;
-        labelIds: string[];
-        hasUnread: boolean;
-        messageCount: number;
-    }>;
+    }): Promise<ThreadResult>;
     getMessage({ messageId, format, }: {
         messageId: string;
         format?: 'full' | 'metadata' | 'minimal' | 'raw';
     }): Promise<ParsedMessage | {
         id: string;
         raw: string;
-    }>;
+    } | AuthError | ApiError>;
     getRawMessage({ messageId }: {
         messageId: string;
-    }): Promise<string>;
+    }): Promise<string | MissingDataError | AuthError | ApiError>;
     sendMessage({ to, subject, body, cc, bcc, threadId, inReplyTo, references, attachments, fromEmail, }: {
         to: Array<{
             name?: string;
@@ -123,31 +140,32 @@ export declare class GmailClient {
         }>;
         fromEmail?: string;
     }): Promise<gmail_v1.Schema$Message>;
-    createDraft({ to, subject, body, cc, bcc, threadId, fromEmail, attachments, }: {
-        to: Array<{
-            name?: string;
-            email: string;
-        }>;
-        subject: string;
+    /**
+     * Reply to a thread. Handles reply-to resolution, reply-all CC computation,
+     * References/In-Reply-To headers, and subject prefixing.
+     */
+    replyToThread({ threadId, body, replyAll, cc, fromEmail, }: {
+        threadId: string;
         body: string;
+        replyAll?: boolean;
         cc?: Array<{
-            name?: string;
             email: string;
         }>;
-        bcc?: Array<{
-            name?: string;
+        fromEmail?: string;
+    }): Promise<EmptyThreadError | AuthError | ApiError | gmail_v1.Schema$Message>;
+    /**
+     * Forward a thread. Fetches the last message, renders its body,
+     * builds the "Forwarded message" block, and sends.
+     */
+    forwardThread({ threadId, to, body, fromEmail, }: {
+        threadId: string;
+        to: Array<{
             email: string;
         }>;
-        threadId?: string;
+        body?: string;
         fromEmail?: string;
-        attachments?: Array<{
-            filename: string;
-            mimeType: string;
-            content: Buffer;
-        }>;
-    }): Promise<gmail_v1.Schema$Draft>;
-    updateDraft({ draftId, to, subject, body, cc, bcc, threadId, fromEmail, attachments, }: {
-        draftId: string;
+    }): Promise<EmptyThreadError | gmail_v1.Schema$Message>;
+    createDraft({ to, subject, body, cc, bcc, threadId, fromEmail, attachments, }: {
         to: Array<{
             name?: string;
             email: string;
@@ -172,7 +190,7 @@ export declare class GmailClient {
     }): Promise<gmail_v1.Schema$Draft>;
     getDraft({ draftId }: {
         draftId: string;
-    }): Promise<{
+    }): Promise<NotFoundError | AuthError | ApiError | {
         id: string;
         message: ParsedMessage;
         to: string[];
@@ -184,16 +202,16 @@ export declare class GmailClient {
         maxResults?: number;
         pageToken?: string;
     }): Promise<{
-        drafts: {
+        drafts: Array<{
             id: string;
             threadId: string | null;
             subject: string;
             to: string[];
             date: string;
             snippet: string;
-        }[];
+        }>;
         nextPageToken: string | null;
-    }>;
+    } | AuthError | ApiError>;
     sendDraft({ draftId }: {
         draftId: string;
     }): Promise<gmail_v1.Schema$Message>;
@@ -202,21 +220,21 @@ export declare class GmailClient {
     }): Promise<void>;
     markAsRead({ threadIds }: {
         threadIds: string[];
-    }): Promise<void>;
+    }): Promise<void | AuthError | ApiError>;
     markAsUnread({ threadIds }: {
         threadIds: string[];
-    }): Promise<void>;
+    }): Promise<void | AuthError | ApiError>;
     star({ threadIds }: {
         threadIds: string[];
-    }): Promise<void>;
+    }): Promise<void | AuthError | ApiError>;
     unstar({ threadIds }: {
         threadIds: string[];
-    }): Promise<void>;
+    }): Promise<void | AuthError | ApiError>;
     modifyLabels({ threadIds, addLabelIds, removeLabelIds, }: {
         threadIds: string[];
         addLabelIds?: string[];
         removeLabelIds?: string[];
-    }): Promise<void>;
+    }): Promise<void | AuthError | ApiError>;
     trash({ threadId }: {
         threadId: string;
     }): Promise<void>;
@@ -225,25 +243,17 @@ export declare class GmailClient {
     }): Promise<void>;
     archive({ threadIds }: {
         threadIds: string[];
-    }): Promise<void>;
-    deleteMessage({ messageId }: {
-        messageId: string;
-    }): Promise<void>;
+    }): Promise<void | AuthError | ApiError>;
+    /** Invalidate thread cache after a thread mutation. */
+    private invalidateAfterThreadMutation;
     /** Moves all spam threads to trash. Does not permanently delete. */
     trashAllSpam(): Promise<{
         count: number;
-    }>;
+    } | AuthError | ApiError>;
     listLabels(): Promise<{
-        id: string;
-        name: string;
-        type: "system" | "user";
-        messageListVisibility: string | null;
-        labelListVisibility: string | null;
-        color: {
-            backgroundColor: string;
-            textColor: string;
-        } | null;
-    }[]>;
+        parsed: ReturnType<typeof GmailClient.parseRawLabels>;
+        raw: gmail_v1.Schema$Label[];
+    } | AuthError | ApiError>;
     getLabel({ labelId }: {
         labelId: string;
     }): Promise<{
@@ -269,45 +279,58 @@ export declare class GmailClient {
         id: string;
         name: string;
     }>;
-    updateLabel({ labelId, name, color, }: {
-        labelId: string;
-        name?: string;
-        color?: {
-            backgroundColor: string;
-            textColor: string;
-        };
-    }): Promise<void>;
     deleteLabel({ labelId }: {
         labelId: string;
     }): Promise<void>;
     getLabelCounts(): Promise<{
-        label: string;
-        count: number;
-    }[]>;
+        parsed: Array<{
+            label: string;
+            count: number;
+        }>;
+        raw: gmail_v1.Schema$Label[];
+        archiveEstimate: number | null;
+    } | AuthError | ApiError>;
     getAttachment({ messageId, attachmentId, }: {
         messageId: string;
         attachmentId: string;
     }): Promise<string>;
-    getMessageAttachments({ messageId }: {
-        messageId: string;
-    }): Promise<{
-        filename: string;
-        mimeType: string;
-        size: number;
-        attachmentId: string;
-        data: string;
-    }[]>;
     getProfile(): Promise<{
         emailAddress: string;
         messagesTotal: number;
         threadsTotal: number;
         historyId: string;
-    }>;
-    getEmailAliases(): Promise<{
+    } | AuthError | ApiError>;
+    /** Parse a raw gmail_v1.Schema$Thread (format: full) into ThreadData. */
+    static parseRawThread(raw: gmail_v1.Schema$Thread): ThreadData;
+    /** Parse a raw gmail_v1.Schema$Message into ParsedMessage. */
+    static parseRawMessage(message: gmail_v1.Schema$Message): ParsedMessage;
+    /** Parse raw gmail_v1.Schema$Thread (format: metadata) into ThreadListItem. */
+    static parseRawThreadListItem(raw: gmail_v1.Schema$Thread): ThreadListItem;
+    /** Parse raw gmail_v1.Schema$Label[] from labels.list into our label objects. */
+    static parseRawLabels(rawLabels: gmail_v1.Schema$Label[]): {
+        id: string;
+        name: string;
+        type: "system" | "user";
+        messageListVisibility: string | null;
+        labelListVisibility: string | null;
+        color: {
+            backgroundColor: string;
+            textColor: string;
+        } | null;
+    }[];
+    /** Parse raw gmail_v1.Schema$Label[] (with counts) into label count objects. */
+    static parseRawLabelCounts(rawLabels: gmail_v1.Schema$Label[], archiveEstimate: number | null): {
+        label: string;
+        count: number;
+    }[];
+    private static extractBodyStatic;
+    private static findBodyPartStatic;
+    private static extractAttachmentMetaStatic;
+    getEmailAliases(): Promise<Array<{
         email: string;
         name?: string;
         primary: boolean;
-    }[]>;
+    }> | AuthError | ApiError>;
     listHistory({ startHistoryId, labelId, historyTypes, }: {
         startHistoryId: string;
         labelId?: string;
@@ -315,21 +338,23 @@ export declare class GmailClient {
     }): Promise<{
         history: gmail_v1.Schema$History[];
         historyId: string;
-    }>;
-    watch({ topicName, labelIds, }: {
-        topicName: string;
-        labelIds?: string[];
-    }): Promise<{
-        historyId: string;
-        expiration: string;
-    }>;
-    stopWatch(): Promise<void>;
+    } | AuthError | ApiError>;
+    /**
+     * Poll for new messages using the Gmail History API.
+     * Yields WatchEvent objects as new messages arrive.
+     * Handles history seeding, expiry re-seeding, and client-side query filtering.
+     * Persists historyId in the DB so it survives across CLI invocations.
+     */
+    watchInbox({ folder, intervalMs, query, once, }?: {
+        folder?: string;
+        intervalMs?: number;
+        query?: string;
+        once?: boolean;
+    }): AsyncGenerator<WatchEvent>;
+    /** Single poll tick from pre-fetched history — yields WatchEvents for new messages. */
+    private pollOnceFromHistory;
     private parseMessage;
     private parseThreadListItem;
-    private extractBody;
-    private findBodyPart;
-    private extractAttachmentMeta;
-    private findAttachmentParts;
     private buildMimeMessage;
     /** Look up a label ID by name. Returns null if not found (never creates). */
     private lookupLabelId;