@timesheet/plugin-google-calendar 1.0.0

package/dist/handlers/handleWebhook.d.ts

@@ -0,0 +1,3 @@
+import { GoogleCalendarConfig, GoogleCalendarSyncInput } from '../lib/types';
+import { GoogleCalendarSyncResult } from '../lib/taskSync';
+export declare const handleWebhook: import("@timesheet/integration-sdk").IntegrationHandler<GoogleCalendarSyncInput, GoogleCalendarSyncResult, GoogleCalendarConfig>;

package/dist/handlers/handleWebhook.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWebhook = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+exports.handleWebhook = (0, integration_sdk_1.defineHandler)(async (input, context) => {
+    context.logger.info('Handling Google Calendar webhook', {
+        installationId: context.installationId
+    });
+    return await (0, taskSync_1.handleGoogleWebhook)(input, context);
+});

package/dist/handlers/listExternalProjects.d.ts

@@ -0,0 +1,3 @@
+import { ExternalEntity } from '@timesheet/integration-sdk';
+import { GoogleCalendarConfig } from '../lib/types';
+export declare const listExternalProjects: import("@timesheet/integration-sdk").IntegrationHandler<void, ExternalEntity[], GoogleCalendarConfig>;

package/dist/handlers/listExternalProjects.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listExternalProjects = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const googleCalendarClient_1 = require("../lib/googleCalendarClient");
+const SYSTEM = 'google-calendar';
+function createClient(context) {
+    return new googleCalendarClient_1.GoogleCalendarClient({
+        getAccessToken: () => context.credentials.getAccessToken('google'),
+        refreshAccessToken: () => context.credentials.refreshToken('google')
+    });
+}
+exports.listExternalProjects = (0, integration_sdk_1.defineHandler)(async (_input, context) => {
+    context.logger.info('Listing Google Calendar calendars', {
+        system: SYSTEM,
+        installationId: context.installationId
+    });
+    const client = createClient(context);
+    return await client.listCalendars();
+});

package/dist/handlers/runFullSync.d.ts

@@ -0,0 +1,3 @@
+import { GoogleCalendarConfig } from '../lib/types';
+import { GoogleCalendarSyncResult } from '../lib/taskSync';
+export declare const runFullSync: import("@timesheet/integration-sdk").IntegrationHandler<void, GoogleCalendarSyncResult, GoogleCalendarConfig>;

package/dist/handlers/runFullSync.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFullSync = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+exports.runFullSync = (0, integration_sdk_1.defineHandler)(async (_input, context) => {
+    context.logger.info('Running Google Calendar full sync', {
+        installationId: context.installationId,
+        syncDirection: context.config?.syncDirection ?? 'bidirectional'
+    });
+    return await (0, taskSync_1.runGoogleCalendarFullSync)(context);
+});

package/dist/handlers/syncTaskFromExternal.d.ts

@@ -0,0 +1,3 @@
+import { GoogleCalendarConfig, GoogleCalendarSyncInput } from '../lib/types';
+import { GoogleCalendarSyncResult } from '../lib/taskSync';
+export declare const syncTaskFromExternal: import("@timesheet/integration-sdk").IntegrationHandler<GoogleCalendarSyncInput, GoogleCalendarSyncResult, GoogleCalendarConfig>;

package/dist/handlers/syncTaskFromExternal.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncTaskFromExternal = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+exports.syncTaskFromExternal = (0, integration_sdk_1.defineHandler)(async (input, context) => {
+    context.logger.info('Syncing task from Google Calendar payload', {
+        installationId: context.installationId,
+        externalTaskId: input?.externalTaskId
+    });
+    return await (0, taskSync_1.handleGoogleWebhook)(input, context);
+});

package/dist/handlers/syncTaskToExternal.d.ts

@@ -0,0 +1,3 @@
+import { GoogleCalendarConfig, GoogleCalendarSyncInput } from '../lib/types';
+import { GoogleCalendarSyncResult } from '../lib/taskSync';
+export declare const syncTaskToExternal: import("@timesheet/integration-sdk").IntegrationHandler<GoogleCalendarSyncInput, GoogleCalendarSyncResult, GoogleCalendarConfig>;

package/dist/handlers/syncTaskToExternal.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncTaskToExternal = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+exports.syncTaskToExternal = (0, integration_sdk_1.defineHandler)(async (input, context) => {
+    context.logger.info('Syncing task to Google Calendar', {
+        installationId: context.installationId,
+        taskId: input?.taskId ?? input?.item?.id,
+        event: input?.event
+    });
+    return await (0, taskSync_1.syncTaskToGoogleCalendar)(input, context);
+});

package/dist/handlers/testConnection.d.ts

@@ -0,0 +1,6 @@
+import { GoogleCalendarConfig } from '../lib/types';
+export declare const testConnection: import("@timesheet/integration-sdk").IntegrationHandler<void, {
+    system: string;
+    ok: boolean;
+    installationId: string;
+}, GoogleCalendarConfig>;

package/dist/handlers/testConnection.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testConnection = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const googleCalendarClient_1 = require("../lib/googleCalendarClient");
+const SYSTEM = 'google-calendar';
+function createClient(context) {
+    return new googleCalendarClient_1.GoogleCalendarClient({
+        getAccessToken: () => context.credentials.getAccessToken('google'),
+        refreshAccessToken: () => context.credentials.refreshToken('google')
+    });
+}
+exports.testConnection = (0, integration_sdk_1.defineHandler)(async (_input, context) => {
+    const client = createClient(context);
+    const ok = await client.testConnection();
+    return {
+        system: SYSTEM,
+        ok,
+        installationId: context.installationId
+    };
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { syncTaskToExternal } from './handlers/syncTaskToExternal';
+export { syncTaskFromExternal } from './handlers/syncTaskFromExternal';
+export { handleWebhook } from './handlers/handleWebhook';
+export { runFullSync } from './handlers/runFullSync';
+export { testConnection } from './handlers/testConnection';
+export { listExternalProjects } from './handlers/listExternalProjects';
+export declare const PLUGIN_SYSTEM = "google-calendar";
+export declare const PLUGIN_NAME = "Google Calendar Sync";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_NAME = exports.PLUGIN_SYSTEM = exports.listExternalProjects = exports.testConnection = exports.runFullSync = exports.handleWebhook = exports.syncTaskFromExternal = exports.syncTaskToExternal = void 0;
+var syncTaskToExternal_1 = require("./handlers/syncTaskToExternal");
+Object.defineProperty(exports, "syncTaskToExternal", { enumerable: true, get: function () { return syncTaskToExternal_1.syncTaskToExternal; } });
+var syncTaskFromExternal_1 = require("./handlers/syncTaskFromExternal");
+Object.defineProperty(exports, "syncTaskFromExternal", { enumerable: true, get: function () { return syncTaskFromExternal_1.syncTaskFromExternal; } });
+var handleWebhook_1 = require("./handlers/handleWebhook");
+Object.defineProperty(exports, "handleWebhook", { enumerable: true, get: function () { return handleWebhook_1.handleWebhook; } });
+var runFullSync_1 = require("./handlers/runFullSync");
+Object.defineProperty(exports, "runFullSync", { enumerable: true, get: function () { return runFullSync_1.runFullSync; } });
+var testConnection_1 = require("./handlers/testConnection");
+Object.defineProperty(exports, "testConnection", { enumerable: true, get: function () { return testConnection_1.testConnection; } });
+var listExternalProjects_1 = require("./handlers/listExternalProjects");
+Object.defineProperty(exports, "listExternalProjects", { enumerable: true, get: function () { return listExternalProjects_1.listExternalProjects; } });
+exports.PLUGIN_SYSTEM = 'google-calendar';
+exports.PLUGIN_NAME = 'Google Calendar Sync';

package/dist/lib/googleCalendarClient.d.ts

@@ -0,0 +1,21 @@
+import { ExternalEntity } from '@timesheet/integration-sdk';
+import { GoogleCalendarEvent, GoogleCalendarEventsResponse } from './types';
+interface GoogleCalendarClientOptions {
+    getAccessToken: () => Promise<string>;
+    refreshAccessToken: () => Promise<string>;
+}
+export declare class GoogleCalendarClient {
+    private readonly getAccessToken;
+    private readonly refreshAccessToken;
+    constructor(options: GoogleCalendarClientOptions);
+    testConnection(): Promise<boolean>;
+    listCalendars(): Promise<ExternalEntity[]>;
+    listEvents(calendarId: string, params: Record<string, string | number | boolean | undefined>): Promise<GoogleCalendarEventsResponse>;
+    getEvent(calendarId: string, eventId: string): Promise<GoogleCalendarEvent | null>;
+    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>;
+    private request;
+    private buildUrl;
+}
+export {};

package/dist/lib/googleCalendarClient.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleCalendarClient = void 0;
+class GoogleCalendarClient {
+    constructor(options) {
+        this.getAccessToken = options.getAccessToken;
+        this.refreshAccessToken = options.refreshAccessToken;
+    }
+    async testConnection() {
+        const calendars = await this.listCalendars();
+        return calendars.length > 0;
+    }
+    async listCalendars() {
+        const result = [];
+        let pageToken;
+        do {
+            const response = await this.request('GET', '/users/me/calendarList', {
+                pageToken
+            });
+            for (const item of response.items ?? []) {
+                if (!item?.id) {
+                    continue;
+                }
+                result.push({
+                    id: item.id,
+                    name: item.summary ?? item.id,
+                    primary: item.primary ?? false
+                });
+            }
+            pageToken = response.nextPageToken;
+        } while (pageToken);
+        return result;
+    }
+    async listEvents(calendarId, params) {
+        return this.request('GET', `/calendars/${encodeURIComponent(calendarId)}/events`, params);
+    }
+    async getEvent(calendarId, eventId) {
+        try {
+            return await this.request('GET', `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`);
+        }
+        catch (error) {
+            if (String(error).includes('(404)')) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async createEvent(calendarId, payload) {
+        return this.request('POST', `/calendars/${encodeURIComponent(calendarId)}/events`, undefined, payload);
+    }
+    async updateEvent(calendarId, eventId, payload) {
+        return this.request('PUT', `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`, undefined, payload);
+    }
+    async deleteEvent(calendarId, eventId) {
+        await this.request('DELETE', `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`);
+    }
+    async request(method, path, query, body, retried = false) {
+        const token = await this.getAccessToken();
+        const response = await fetch(this.buildUrl(path, query), {
+            method,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined
+        });
+        if (response.status === 401 && !retried) {
+            const refreshed = await this.refreshAccessToken();
+            if (refreshed) {
+                return this.request(method, path, query, body, true);
+            }
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Google Calendar API ${method} ${path} failed (${response.status}): ${errorText}`);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return (await response.json());
+    }
+    buildUrl(path, query) {
+        const url = new URL(`https://www.googleapis.com/calendar/v3${path}`);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined || value === null || value === '') {
+                    continue;
+                }
+                url.searchParams.append(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+}
+exports.GoogleCalendarClient = GoogleCalendarClient;

package/dist/lib/taskSync.d.ts

@@ -0,0 +1,11 @@
+import { IntegrationContext } from '@timesheet/integration-sdk';
+import { GoogleCalendarConfig, GoogleCalendarSyncInput } from './types';
+export interface GoogleCalendarSyncResult {
+    system: string;
+    status: string;
+    syncedCount: number;
+    details?: Record<string, unknown>;
+}
+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>;

package/dist/lib/taskSync.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncTaskToGoogleCalendar = syncTaskToGoogleCalendar;
+exports.runGoogleCalendarFullSync = runGoogleCalendarFullSync;
+exports.handleGoogleWebhook = handleGoogleWebhook;
+const googleCalendarClient_1 = require("./googleCalendarClient");
+const SYSTEM = 'google-calendar';
+const PROJECT_ENTITY = 'project';
+const TASK_ENTITY = 'task';
+async function syncTaskToGoogleCalendar(input, context) {
+    const taskId = resolveTaskId(input);
+    if (!taskId) {
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'missing-task-id' } };
+    }
+    const task = await loadTask(taskId, input, context);
+    if (!task) {
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'task-not-found' } };
+    }
+    const projectId = task.project?.id;
+    if (!projectId) {
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'missing-project' } };
+    }
+    const projectMapping = await context.mappings.get({
+        system: SYSTEM,
+        entity: PROJECT_ENTITY,
+        localId: projectId
+    });
+    const externalCalendarId = projectMapping?.externalId;
+    if (!externalCalendarId) {
+        return {
+            system: SYSTEM,
+            status: 'skipped',
+            syncedCount: 0,
+            details: { reason: 'missing-project-mapping', projectId }
+        };
+    }
+    const client = createClient(context);
+    const taskMapping = await context.mappings.get({
+        system: SYSTEM,
+        entity: TASK_ENTITY,
+        localId: task.id
+    });
+    if (task.deleted) {
+        if (taskMapping?.externalId) {
+            const mappedCalendarId = getMappedCalendarId(taskMapping) ?? externalCalendarId;
+            await client.deleteEvent(mappedCalendarId, taskMapping.externalId);
+            await context.mappings.delete({
+                system: SYSTEM,
+                entity: TASK_ENTITY,
+                localId: task.id
+            });
+            return { system: SYSTEM, status: 'deleted', syncedCount: 1 };
+        }
+        return { system: SYSTEM, status: 'skipped', syncedCount: 0, details: { reason: 'already-deleted' } };
+    }
+    const payload = buildGoogleEventPayload(task);
+    let externalEvent;
+    if (taskMapping?.externalId) {
+        const mappedCalendarId = getMappedCalendarId(taskMapping) ?? externalCalendarId;
+        externalEvent = await client.updateEvent(mappedCalendarId, taskMapping.externalId, payload);
+    }
+    else {
+        const duplicate = await findEventByTimesheetId(client, externalCalendarId, task.id);
+        if (duplicate?.id) {
+            externalEvent = duplicate;
+        }
+        else {
+            externalEvent = await client.createEvent(externalCalendarId, payload);
+        }
+    }
+    if (!externalEvent?.id) {
+        return {
+            system: SYSTEM,
+            status: 'failed',
+            syncedCount: 0,
+            details: { reason: 'missing-external-id' }
+        };
+    }
+    await context.mappings.upsert({
+        system: SYSTEM,
+        entity: TASK_ENTITY,
+        localId: task.id,
+        externalId: externalEvent.id,
+        externalLabel: externalEvent.summary ?? task.description ?? task.id,
+        metadata: {
+            calendarId: externalCalendarId,
+            etag: externalEvent.etag ?? '',
+            updated: externalEvent.updated ?? ''
+        },
+        syncStatus: 'SYNCED'
+    });
+    return {
+        system: SYSTEM,
+        status: 'synced',
+        syncedCount: 1,
+        details: { taskId: task.id, externalTaskId: externalEvent.id, calendarId: externalCalendarId }
+    };
+}
+async function runGoogleCalendarFullSync(context) {
+    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;
+        }
+        const perCalendarCount = await syncCalendar(context, mapping);
+        syncedCount += perCalendarCount;
+    }
+    return {
+        system: SYSTEM,
+        status: 'completed',
+        syncedCount,
+        details: { calendarCount: projectMappings.length }
+    };
+}
+async function handleGoogleWebhook(input, context) {
+    const resourceState = getHeader(input, 'x-goog-resource-state')?.toLowerCase();
+    if (resourceState === 'sync') {
+        return {
+            system: SYSTEM,
+            status: 'acknowledged',
+            syncedCount: 0,
+            details: { resourceState }
+        };
+    }
+    const channelId = getHeader(input, 'x-goog-channel-id');
+    const allProjectMappings = await context.mappings.list({ system: SYSTEM, entity: PROJECT_ENTITY });
+    let projectMappings = allProjectMappings;
+    if (channelId) {
+        projectMappings = allProjectMappings.filter((mapping) => {
+            const metadata = mapping.metadata ?? {};
+            const watchChannelId = readMetadataString(metadata, 'watchChannelId')
+                || readMetadataString(metadata, 'channelId');
+            return watchChannelId === channelId;
+        });
+    }
+    if (projectMappings.length === 0 && input.calendarId) {
+        projectMappings = allProjectMappings.filter((mapping) => mapping.externalId === input.calendarId);
+    }
+    if (projectMappings.length === 0) {
+        return {
+            system: SYSTEM,
+            status: 'ignored',
+            syncedCount: 0,
+            details: { reason: 'no-matching-calendar-mapping' }
+        };
+    }
+    let syncedCount = 0;
+    for (const mapping of projectMappings) {
+        syncedCount += await syncCalendar(context, mapping);
+    }
+    return {
+        system: SYSTEM,
+        status: 'completed',
+        syncedCount,
+        details: {
+            channelId: channelId ?? '',
+            mappedCalendars: projectMappings.length
+        }
+    };
+}
+async function syncCalendar(context, projectMapping) {
+    if (!projectMapping.externalId) {
+        return 0;
+    }
+    const client = createClient(context);
+    const calendarId = projectMapping.externalId;
+    const syncStateKey = getSyncTokenStateKey(calendarId);
+    const metadataSyncToken = readMetadataString(projectMapping.metadata ?? {}, 'syncToken');
+    let syncToken = (await context.state.get(syncStateKey)) ?? undefined;
+    if (!syncToken && metadataSyncToken) {
+        syncToken = metadataSyncToken;
+    }
+    let pageToken;
+    let nextSyncToken;
+    let syncedCount = 0;
+    do {
+        const response = await client.listEvents(calendarId, {
+            showDeleted: true,
+            singleEvents: true,
+            syncToken,
+            pageToken,
+            timeMin: !syncToken ? new Date(Date.now() - (365 * 24 * 60 * 60 * 1000)).toISOString() : undefined
+        });
+        for (const event of response.items ?? []) {
+            const synced = await syncSingleGoogleEvent(context, projectMapping, calendarId, event);
+            if (synced) {
+                syncedCount += 1;
+            }
+        }
+        nextSyncToken = response.nextSyncToken ?? nextSyncToken;
+        pageToken = response.nextPageToken;
+    } while (pageToken);
+    if (nextSyncToken) {
+        await context.state.set(syncStateKey, nextSyncToken);
+    }
+    return syncedCount;
+}
+async function syncSingleGoogleEvent(context, projectMapping, calendarId, event) {
+    if (!event?.id) {
+        return false;
+    }
+    const taskMapping = await context.mappings.findByExternal({
+        system: SYSTEM,
+        entity: TASK_ENTITY,
+        externalId: event.id
+    });
+    if (event.status === 'cancelled') {
+        if (taskMapping?.localId) {
+            await context.data.deleteTask(taskMapping.localId);
+            await context.mappings.delete({
+                system: SYSTEM,
+                entity: TASK_ENTITY,
+                localId: taskMapping.localId
+            });
+            return true;
+        }
+        return false;
+    }
+    const dateRange = toTaskDateRange(event);
+    if (!dateRange) {
+        return false;
+    }
+    const localTaskIdFromExtendedProperties = event.extendedProperties?.private?.timesheetId;
+    if (!taskMapping?.localId) {
+        if (localTaskIdFromExtendedProperties) {
+            return false;
+        }
+        const created = await context.data.createTask({
+            projectId: projectMapping.localId,
+            startDateTime: dateRange.startDateTime,
+            endDateTime: dateRange.endDateTime,
+            description: event.description ?? '',
+            location: event.location
+        });
+        await context.mappings.upsert({
+            system: SYSTEM,
+            entity: TASK_ENTITY,
+            localId: created.id,
+            externalId: event.id,
+            externalLabel: event.summary ?? event.id,
+            metadata: {
+                calendarId,
+                etag: event.etag ?? '',
+                updated: event.updated ?? ''
+            },
+            syncStatus: 'SYNCED'
+        });
+        return true;
+    }
+    const existing = await context.data.getTask(taskMapping.localId);
+    const externalUpdatedAt = event.updated ? Date.parse(event.updated) : 0;
+    if (existing?.lastUpdate && externalUpdatedAt > 0 && externalUpdatedAt <= existing.lastUpdate) {
+        return false;
+    }
+    await context.data.updateTask(taskMapping.localId, {
+        projectId: projectMapping.localId,
+        startDateTime: dateRange.startDateTime,
+        endDateTime: dateRange.endDateTime,
+        description: event.description ?? '',
+        location: event.location
+    });
+    await context.mappings.upsert({
+        system: SYSTEM,
+        entity: TASK_ENTITY,
+        localId: taskMapping.localId,
+        externalId: event.id,
+        externalLabel: event.summary ?? event.id,
+        metadata: {
+            calendarId,
+            etag: event.etag ?? '',
+            updated: event.updated ?? ''
+        },
+        syncStatus: 'SYNCED'
+    });
+    return true;
+}
+function toTaskDateRange(event) {
+    const startDateTime = event.start?.dateTime;
+    const endDateTime = event.end?.dateTime;
+    if (!startDateTime || !endDateTime) {
+        return null;
+    }
+    const start = new Date(startDateTime);
+    const end = new Date(endDateTime);
+    if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+        return null;
+    }
+    return {
+        startDateTime: start.toISOString(),
+        endDateTime: end.toISOString()
+    };
+}
+function buildGoogleEventPayload(task) {
+    const startDateTime = task.startDateTime ? new Date(task.startDateTime).toISOString() : undefined;
+    const endDateTime = task.endDateTime ? new Date(task.endDateTime).toISOString() : undefined;
+    if (!startDateTime || !endDateTime) {
+        throw new Error(`Task ${task.id} is missing start or end datetime.`);
+    }
+    const summary = task.project?.title
+        ? [task.project.title, task.project.employer].filter(Boolean).join(' - ')
+        : (task.description ?? 'Timesheet task');
+    const creatorEmail = task.member?.email;
+    const creatorDisplayName = task.member?.displayName;
+    return {
+        summary,
+        location: task.location ?? null,
+        description: task.description ?? '',
+        start: {
+            dateTime: startDateTime
+        },
+        end: {
+            dateTime: endDateTime
+        },
+        extendedProperties: {
+            private: {
+                timesheetId: task.id
+            }
+        },
+        creator: creatorEmail
+            ? {
+                email: creatorEmail,
+                displayName: creatorDisplayName
+            }
+            : undefined
+    };
+}
+async function findEventByTimesheetId(client, calendarId, taskId) {
+    const response = await client.listEvents(calendarId, {
+        privateExtendedProperty: `timesheetId=${taskId}`,
+        maxResults: 1,
+        singleEvents: true
+    });
+    const item = (response.items ?? [])[0];
+    return item ?? null;
+}
+function getMappedCalendarId(mapping) {
+    const metadata = mapping.metadata ?? {};
+    return readMetadataString(metadata, 'calendarId');
+}
+function getSyncTokenStateKey(calendarId) {
+    return `google-calendar:sync-token:${calendarId}`;
+}
+function createClient(context) {
+    return new googleCalendarClient_1.GoogleCalendarClient({
+        getAccessToken: () => context.credentials.getAccessToken('google'),
+        refreshAccessToken: () => context.credentials.refreshToken('google')
+    });
+}
+async function loadTask(taskId, input, context) {
+    try {
+        return await context.data.getTask(taskId);
+    }
+    catch {
+        if (input?.item && typeof input.item === 'object') {
+            return input.item;
+        }
+        return null;
+    }
+}
+function resolveTaskId(input) {
+    return input?.taskId
+        || input?.item?.taskId
+        || input?.item?.id;
+}
+function getHeader(input, name) {
+    const mergedHeaders = {
+        ...(input?.headers ?? {})
+    };
+    if (input?.body && typeof input.body === 'object') {
+        const nestedHeaders = input.body.headers;
+        if (nestedHeaders && typeof nestedHeaders === 'object') {
+            Object.assign(mergedHeaders, nestedHeaders);
+        }
+    }
+    const key = Object.keys(mergedHeaders).find((header) => header.toLowerCase() === name.toLowerCase());
+    if (!key) {
+        return undefined;
+    }
+    const value = mergedHeaders[key];
+    return value === undefined || value === null ? undefined : String(value);
+}
+function readMetadataString(metadata, key) {
+    const value = metadata[key];
+    if (typeof value === 'string' && value.trim().length > 0) {
+        return value;
+    }
+    return undefined;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,52 @@
+import { TaskDto } from '@timesheet/integration-sdk';
+export interface GoogleCalendarConfig {
+    syncDirection?: 'bidirectional' | 'timesheet-to-google' | 'google-to-timesheet' | 'timesheet-to-external' | 'external-to-timesheet';
+}
+export interface GoogleCalendarDateTime {
+    dateTime?: string;
+    date?: string;
+    timeZone?: string;
+}
+export interface GoogleCalendarEvent {
+    id: string;
+    status?: string;
+    summary?: string;
+    description?: string;
+    location?: string;
+    created?: string;
+    updated?: string;
+    start?: GoogleCalendarDateTime;
+    end?: GoogleCalendarDateTime;
+    etag?: string;
+    extendedProperties?: {
+        private?: Record<string, string>;
+    };
+}
+export interface GoogleCalendarEventsResponse {
+    items?: GoogleCalendarEvent[];
+    nextPageToken?: string;
+    nextSyncToken?: string;
+}
+export interface GoogleCalendarListResponse {
+    items?: Array<{
+        id: string;
+        summary?: string;
+        primary?: boolean;
+    }>;
+    nextPageToken?: string;
+}
+export interface GoogleCalendarSyncInput {
+    event?: string;
+    triggerId?: string;
+    taskId?: string;
+    item?: Partial<TaskDto> & {
+        taskId?: string;
+        id?: string;
+    };
+    method?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    body?: unknown;
+    externalTaskId?: string;
+    calendarId?: string;
+}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/manifest.json

@@ -0,0 +1,154 @@
+{
+  "id": "google-calendar-sync",
+  "name": "Google Calendar Sync",
+  "version": "1.0.0",
+  "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"],
+  "externalAuth": [
+    {
+      "id": "google",
+      "type": "oauth2",
+      "oauth": {
+        "authorizeUrl": "https://accounts.google.com/o/oauth2/v2/auth",
+        "tokenUrl": "https://oauth2.googleapis.com/token",
+        "scopes": [
+          "https://www.googleapis.com/auth/calendar.readonly",
+          "https://www.googleapis.com/auth/calendar.events"
+        ]
+      }
+    }
+  ],
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "syncDirection": {
+        "type": "string",
+        "title": "Sync Direction",
+        "enum": ["bidirectional", "timesheet-to-google", "google-to-timesheet"],
+        "default": "bidirectional",
+        "x-ui-widget": "radio"
+      }
+    },
+    "required": ["syncDirection"]
+  },
+  "mappingSchema": {
+    "system": "google-calendar",
+    "mappings": [
+      {
+        "id": "projects",
+        "title": "Calendar Mapping",
+        "description": "Map Timesheet projects to Google Calendars",
+        "localEntity": {
+          "type": "project",
+          "label": "Timesheet Project",
+          "display": "{{title}}"
+        },
+        "externalEntity": {
+          "type": "calendar",
+          "label": "Google Calendar",
+          "fetchAction": "list-external-projects"
+        },
+        "required": true,
+        "minMappings": 1
+      }
+    ]
+  },
+  "triggers": [
+    {
+      "id": "task-changed",
+      "type": "event",
+      "name": "Task Changed",
+      "description": "Sync task create/update/delete events to Google Calendar",
+      "events": ["task.create", "task.update", "task.delete"],
+      "configurable": true,
+      "actionId": "sync-task-to-external"
+    },
+    {
+      "id": "integration-webhook",
+      "type": "webhook",
+      "name": "Google Calendar Webhook",
+      "description": "Receive inbound changes from Google Calendar",
+      "configurable": false,
+      "actionId": "handle-webhook",
+      "webhook": {}
+    },
+    {
+      "id": "full-sync",
+      "type": "schedule",
+      "name": "Scheduled Full Sync",
+      "description": "Run incremental synchronization for all mapped calendars",
+      "schedule": "0 2 * * *",
+      "timezone": "UTC",
+      "configurable": true,
+      "actionId": "run-full-sync"
+    },
+    {
+      "id": "manual-sync",
+      "type": "user_action",
+      "name": "Manual Sync",
+      "description": "Trigger a sync from settings",
+      "userAction": {
+        "label": "Sync Now",
+        "placement": "settings"
+      },
+      "actionId": "run-full-sync"
+    }
+  ],
+  "actions": [
+    {
+      "id": "sync-task-to-external",
+      "name": "Sync task to Google Calendar",
+      "handler": "syncTaskToExternal"
+    },
+    {
+      "id": "sync-task-from-external",
+      "name": "Sync task from Google Calendar",
+      "handler": "syncTaskFromExternal",
+      "internal": true
+    },
+    {
+      "id": "handle-webhook",
+      "handler": "handleWebhook",
+      "internal": true
+    },
+    {
+      "id": "run-full-sync",
+      "name": "Run full sync",
+      "handler": "runFullSync"
+    },
+    {
+      "id": "test-connection",
+      "name": "Test connection",
+      "handler": "testConnection"
+    },
+    {
+      "id": "list-external-projects",
+      "handler": "listExternalProjects",
+      "internal": true
+    }
+  ],
+  "pages": [
+    {
+      "id": "dashboard",
+      "title": "Sync Dashboard",
+      "icon": "chart-bar",
+      "layout": "dashboard",
+      "widgets": [
+        {
+          "id": "manual-sync-btn",
+          "type": "action_button",
+          "title": "Manual Sync",
+          "config": {
+            "actionId": "run-full-sync",
+            "label": "Run Full Sync",
+            "variant": "primary"
+          }
+        }
+      ]
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@timesheet/plugin-google-calendar",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "manifest.json"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@timesheet/integration-sdk": "^0.1.0"
+  }
+}