@timesheet/plugin-google-calendar 1.0.0 → 1.0.1

package/dist/handlers/runFullSync.js

@@ -8,5 +8,8 @@ exports.runFullSync = (0, integration_sdk_1.defineHandler)(async (_input, contex
         installationId: context.installationId,
         syncDirection: context.config?.syncDirection ?? 'bidirectional'
     });
-    return await (0, taskSync_1.runGoogleCalendarFullSync)(context);
+    const result = await (0, taskSync_1.runGoogleCalendarFullSync)(context);
+    // Ensure watch channels are active for inbound push notifications
+    await (0, taskSync_1.ensureWatchChannels)(context);
+    return result;
 });

package/dist/lib/googleCalendarClient.d.ts

@@ -15,6 +15,12 @@ export declare class GoogleCalendarClient {
     createEvent(calendarId: string, payload: Record<string, unknown>): Promise<GoogleCalendarEvent>;
     updateEvent(calendarId: string, eventId: string, payload: Record<string, unknown>): Promise<GoogleCalendarEvent>;
     deleteEvent(calendarId: string, eventId: string): Promise<void>;
+    watchEvents(calendarId: string, channelId: string, webhookUrl: string, ttlSeconds?: number): Promise<{
+        id?: string;
+        resourceId?: string;
+        expiration?: string;
+    }>;
+    stopWatch(channelId: string, resourceId: string): Promise<void>;
     private request;
     private buildUrl;
 }

package/dist/lib/googleCalendarClient.js

@@ -54,6 +54,30 @@ class GoogleCalendarClient {
     async deleteEvent(calendarId, eventId) {
         await this.request('DELETE', `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`);
     }
+    async watchEvents(calendarId, channelId, webhookUrl, ttlSeconds = 604800) {
+        return this.request('POST', `/calendars/${encodeURIComponent(calendarId)}/events/watch`, undefined, {
+            id: channelId,
+            type: 'web_hook',
+            address: webhookUrl,
+            params: { ttl: String(ttlSeconds) }
+        });
+    }
+    async stopWatch(channelId, resourceId) {
+        const token = await this.getAccessToken();
+        const response = await fetch('https://www.googleapis.com/calendar/v3/channels/stop', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ id: channelId, resourceId })
+        });
+        // 404 means channel already expired — not an error
+        if (!response.ok && response.status !== 404) {
+            const errorText = await response.text();
+            throw new Error(`Google Calendar API channels/stop failed (${response.status}): ${errorText}`);
+        }
+    }
     async request(method, path, query, body, retried = false) {
         const token = await this.getAccessToken();
         const response = await fetch(this.buildUrl(path, query), {

package/dist/lib/taskSync.d.ts

@@ -9,3 +9,4 @@ export interface GoogleCalendarSyncResult {
 export declare function syncTaskToGoogleCalendar(input: GoogleCalendarSyncInput, context: IntegrationContext<GoogleCalendarConfig>): Promise<GoogleCalendarSyncResult>;
 export declare function runGoogleCalendarFullSync(context: IntegrationContext<GoogleCalendarConfig>): Promise<GoogleCalendarSyncResult>;
 export declare function handleGoogleWebhook(input: GoogleCalendarSyncInput, context: IntegrationContext<GoogleCalendarConfig>): Promise<GoogleCalendarSyncResult>;
+export declare function ensureWatchChannels(context: IntegrationContext<GoogleCalendarConfig>): Promise<void>;

package/dist/lib/taskSync.js

@@ -3,11 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncTaskToGoogleCalendar = syncTaskToGoogleCalendar;
 exports.runGoogleCalendarFullSync = runGoogleCalendarFullSync;
 exports.handleGoogleWebhook = handleGoogleWebhook;
+exports.ensureWatchChannels = ensureWatchChannels;
 const googleCalendarClient_1 = require("./googleCalendarClient");
 const SYSTEM = 'google-calendar';
 const PROJECT_ENTITY = 'project';
 const TASK_ENTITY = 'task';
 async function syncTaskToGoogleCalendar(input, context) {
+    const syncDirection = context.config?.syncDirection ?? 'bidirectional';
+    if (syncDirection === 'google-to-timesheet' || syncDirection === 'external-to-timesheet') {
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'sync-direction-mismatch' } };
+    }
     const taskId = resolveTaskId(input);
     if (!taskId) {
         return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'missing-task-id' } };
@@ -53,7 +58,14 @@ async function syncTaskToGoogleCalendar(input, context) {
         }
         return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'already-deleted' } };
     }
-    const payload = buildGoogleEventPayload(task);
+    let payload;
+    try {
+        payload = buildGoogleEventPayload(task);
+    }
+    catch (err) {
+        context.logger.warn('Failed to build event payload', { taskId: task.id, error: String(err) });
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'invalid-task-data', taskId: task.id } };
+    }
     let externalEvent;
     if (taskMapping?.externalId) {
         const mappedCalendarId = getMappedCalendarId(taskMapping) ?? externalCalendarId;
@@ -97,26 +109,34 @@ async function syncTaskToGoogleCalendar(input, context) {
     };
 }
 async function runGoogleCalendarFullSync(context) {
+    const syncDirection = context.config?.syncDirection ?? 'bidirectional';
+    const allowInbound = syncDirection !== 'timesheet-to-google' && syncDirection !== 'timesheet-to-external';
     const projectMappings = await context.mappings.list({ system: SYSTEM, entity: PROJECT_ENTITY });
     if (projectMappings.length === 0) {
         return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'missing-project-mappings' } };
     }
     let syncedCount = 0;
-    for (const mapping of projectMappings) {
-        if (!mapping.externalId) {
-            continue;
+    if (allowInbound) {
+        for (const mapping of projectMappings) {
+            if (!mapping.externalId) {
+                continue;
+            }
+            const perCalendarCount = await syncCalendar(context, mapping);
+            syncedCount += perCalendarCount;
         }
-        const perCalendarCount = await syncCalendar(context, mapping);
-        syncedCount += perCalendarCount;
     }
     return {
         system: SYSTEM,
         status: 'completed',
         syncedCount,
-        details: { calendarCount: projectMappings.length }
+        details: { calendarCount: projectMappings.length, syncDirection }
     };
 }
 async function handleGoogleWebhook(input, context) {
+    const syncDirection = context.config?.syncDirection ?? 'bidirectional';
+    if (syncDirection === 'timesheet-to-google' || syncDirection === 'timesheet-to-external') {
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'sync-direction-mismatch' } };
+    }
     const resourceState = getHeader(input, 'x-goog-resource-state')?.toLowerCase();
     if (resourceState === 'sync') {
         return {
@@ -279,13 +299,20 @@ async function syncSingleGoogleEvent(context, projectMapping, calendarId, event)
     return true;
 }
 function toTaskDateRange(event) {
-    const startDateTime = event.start?.dateTime;
-    const endDateTime = event.end?.dateTime;
-    if (!startDateTime || !endDateTime) {
+    let startRaw = event.start?.dateTime;
+    let endRaw = event.end?.dateTime;
+    // Handle all-day events (date field instead of dateTime)
+    if (!startRaw && event.start?.date) {
+        startRaw = `${event.start.date}T00:00:00Z`;
+    }
+    if (!endRaw && event.end?.date) {
+        endRaw = `${event.end.date}T00:00:00Z`;
+    }
+    if (!startRaw || !endRaw) {
         return null;
     }
-    const start = new Date(startDateTime);
-    const end = new Date(endDateTime);
+    const start = new Date(startRaw);
+    const end = new Date(endRaw);
     if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
         return null;
     }
@@ -383,6 +410,78 @@ function getHeader(input, name) {
     const value = mergedHeaders[key];
     return value === undefined || value === null ? undefined : String(value);
 }
+async function ensureWatchChannels(context) {
+    // The webhook URL is passed via the context metadata (set by the backend runtime)
+    const contextAny = context;
+    const metadata = contextAny['metadata'];
+    const webhooks = metadata?.['webhooks'];
+    const webhookUrl = webhooks?.['integration-webhook'];
+    if (!webhookUrl) {
+        context.logger.info('No webhook URL available — skipping watch channel registration');
+        return;
+    }
+    const projectMappings = await context.mappings.list({ system: SYSTEM, entity: PROJECT_ENTITY });
+    if (projectMappings.length === 0) {
+        return;
+    }
+    const client = createClient(context);
+    const now = Date.now();
+    const watchTtlSeconds = 7 * 24 * 60 * 60; // 7 days
+    for (const mapping of projectMappings) {
+        if (!mapping.externalId) {
+            continue;
+        }
+        const metadata = mapping.metadata ?? {};
+        const existingExpiration = readMetadataString(metadata, 'watchExpiration');
+        if (existingExpiration) {
+            const expiresAt = Number(existingExpiration);
+            if (expiresAt > now + 3600000) {
+                // Watch still has > 1 hour remaining, skip
+                continue;
+            }
+            // Stop the old channel before creating a new one
+            const oldChannelId = readMetadataString(metadata, 'watchChannelId');
+            const oldResourceId = readMetadataString(metadata, 'watchResourceId');
+            if (oldChannelId && oldResourceId) {
+                try {
+                    await client.stopWatch(oldChannelId, oldResourceId);
+                }
+                catch (err) {
+                    context.logger.warn('Failed to stop old watch channel', { calendarId: mapping.externalId, error: String(err) });
+                }
+            }
+        }
+        try {
+            const channelId = `ts-${context.installationId}-${mapping.externalId}-${now}`.substring(0, 64);
+            const watchResult = await client.watchEvents(mapping.externalId, channelId, webhookUrl, watchTtlSeconds);
+            await context.mappings.upsert({
+                system: SYSTEM,
+                entity: PROJECT_ENTITY,
+                localId: mapping.localId,
+                externalId: mapping.externalId,
+                externalLabel: mapping.externalLabel,
+                metadata: {
+                    ...metadata,
+                    watchChannelId: channelId,
+                    watchResourceId: watchResult.resourceId ?? '',
+                    watchExpiration: watchResult.expiration ?? String(now + watchTtlSeconds * 1000)
+                },
+                syncStatus: 'SYNCED'
+            });
+            context.logger.info('Registered watch channel', {
+                calendarId: mapping.externalId,
+                channelId,
+                expiration: watchResult.expiration
+            });
+        }
+        catch (err) {
+            context.logger.warn('Failed to register watch channel', {
+                calendarId: mapping.externalId,
+                error: String(err)
+            });
+        }
+    }
+}
 function readMetadataString(metadata, key) {
     const value = metadata[key];
     if (typeof value === 'string' && value.trim().length > 0) {

package/manifest.json

@@ -1,13 +1,13 @@
 {
   "id": "google-calendar-sync",
   "name": "Google Calendar Sync",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Synchronize Timesheet tasks with Google Calendar",
   "longDescription": "Bidirectional synchronization between Timesheet tasks and Google Calendar events.",
   "icon": "google-calendar",
   "category": "calendar",
   "tags": ["sync", "timesheet", "google-calendar", "calendar"],
-  "dataAccess": ["projects", "tasks", "colleagues", "settings"],
+  "dataAccess": ["projects", "tasks"],
   "externalAuth": [
     {
       "id": "google",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timesheet/plugin-google-calendar",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [