@timesheet/plugin-asana 1.4.1

package/README.md

@@ -0,0 +1,42 @@
+# Asana Sync
+
+> Synchronize Timesheet todos and time entries with Asana.
+
+Bidirectional synchronization between Timesheet and Asana. Timesheet todos are mirrored 1:1 with Asana tasks in the mapped project, and Timesheet time entries attached to a todo are logged as Asana time-tracking entries on the corresponding task. Changes made in Asana flow back through webhooks and scheduled syncs.
+
+- Package: `@timesheet/plugin-asana`
+- Manifest id: `asana-sync`
+- Category: project-management
+
+## Authentication
+
+OAuth 2.0 against Asana.
+
+## Configuration
+
+| Option | Required | Default | Description |
+| --- | --- | --- | --- |
+| `syncDirection` | yes | `bidirectional` | One of `bidirectional`, `timesheet-to-asana`, `asana-to-timesheet`. |
+| `workspaceId` | no | | Optional. When set, project lookups are scoped to this Asana workspace gid. |
+
+## Mappings
+
+- **Project mapping**: Timesheet project to Asana project.
+
+## Triggers
+
+- **Todo Changed** (event): syncs todo create, update, and delete events to Asana tasks.
+- **Time Entry Changed** (event): logs Timesheet time entries as Asana time-tracking entries.
+- **Asana Webhook** (webhook): receives inbound task changes from Asana.
+- **Scheduled Full Sync** (daily at 02:00 UTC): runs a complete reconciliation sync.
+- **Manual Sync** (user action): runs a full sync from the integration settings page.
+
+## Development
+
+```bash
+npm install        # or: npm ci
+npm run build      # compile TypeScript into dist/
+npm run typecheck
+```
+
+The package ships `dist/` and `manifest.json`; the sandboxed plugin runtime loads it by package name, version, and integrity. Shared tests live in `integrations/tests/` and run from the `integrations/` root with `npm test`.

package/dist/handlers/handleSyncBatch.d.ts

@@ -0,0 +1,4 @@
+import { SyncModeInput } from '@timesheet/integration-sdk';
+import { AsanaConfig } from '../lib/types';
+import { AsanaSyncResult } from '../lib/taskSync';
+export declare const handleSyncBatch: import("@timesheet/integration-sdk").IntegrationHandler<SyncModeInput, AsanaSyncResult, AsanaConfig>;

package/dist/handlers/handleSyncBatch.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSyncBatch = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+const SYSTEM = 'asana';
+const PROJECT_ENTITY = 'project';
+const TODO_ENTITY = 'todo';
+const TASK_ENTITY = 'task';
+exports.handleSyncBatch = (0, integration_sdk_1.defineHandler)(async (input, context) => {
+    context.logger.info('Processing Asana sync batch', {
+        sinceVersion: input.sinceVersion,
+        headVersion: input.headVersion,
+        changeCount: input.changes.length,
+        hasMore: input.hasMore
+    });
+    const [projectMappings, todoMappings, taskMappings] = await Promise.all([
+        context.mappings.list({ system: SYSTEM, entity: PROJECT_ENTITY }),
+        context.mappings.list({ system: SYSTEM, entity: TODO_ENTITY }),
+        context.mappings.list({ system: SYSTEM, entity: TASK_ENTITY })
+    ]);
+    const projectMappingByLocalId = new Map();
+    for (const m of projectMappings)
+        projectMappingByLocalId.set(m.localId, m);
+    const todoMappingByLocalId = new Map();
+    for (const m of todoMappings)
+        todoMappingByLocalId.set(m.localId, m);
+    const taskMappingByLocalId = new Map();
+    for (const m of taskMappings)
+        taskMappingByLocalId.set(m.localId, m);
+    const caches = { projectMappingByLocalId, todoMappingByLocalId, taskMappingByLocalId };
+    let syncedCount = 0;
+    const errors = [];
+    // Process todo changes first so any task changes within the same batch can
+    // find a fresh todo→Asana-task mapping to attach time entries to.
+    const orderedChanges = [...input.changes].sort((a, b) => {
+        if (a.entityType === b.entityType)
+            return 0;
+        if (a.entityType === 'todo')
+            return -1;
+        if (b.entityType === 'todo')
+            return 1;
+        return 0;
+    });
+    for (const change of orderedChanges) {
+        const op = change.op === 'DELETE' ? 'delete' : 'update';
+        const item = change.item;
+        try {
+            let result = null;
+            if (change.entityType === 'todo') {
+                result = await (0, taskSync_1.syncTodoToAsana)({
+                    event: `todo.${op}`,
+                    entityId: change.entityId,
+                    item
+                }, context, caches);
+            }
+            else if (change.entityType === 'task') {
+                result = await (0, taskSync_1.syncTimesheetTaskToAsana)({
+                    event: `task.${op}`,
+                    taskId: change.entityId,
+                    entityId: change.entityId,
+                    item
+                }, context, caches);
+            }
+            else {
+                continue;
+            }
+            if (result.status === 'synced' || result.status === 'deleted') {
+                syncedCount++;
+            }
+            else if (result.status === 'skipped') {
+                context.logger.debug('Change skipped', {
+                    entityId: change.entityId,
+                    entityType: change.entityType,
+                    reason: result.details?.reason
+                });
+            }
+        }
+        catch (err) {
+            context.logger.error('Failed to sync change', {
+                entityId: change.entityId,
+                entityType: change.entityType,
+                op: change.op,
+                error: String(err)
+            });
+            errors.push({ entityId: change.entityId, entityType: change.entityType, error: String(err) });
+        }
+    }
+    return {
+        system: SYSTEM,
+        status: errors.length > 0 ? 'partial' : 'completed',
+        syncedCount,
+        details: {
+            sinceVersion: input.sinceVersion,
+            headVersion: input.headVersion,
+            totalChanges: input.changes.length,
+            hasMore: input.hasMore,
+            errors: errors.length > 0 ? errors : undefined
+        }
+    };
+});

package/dist/handlers/handleWebhook.d.ts

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

package/dist/handlers/handleWebhook.js

@@ -0,0 +1,12 @@
+"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 Asana webhook', {
+        installationId: context.installationId,
+        hasBody: !!input?.body
+    });
+    return await (0, taskSync_1.handleAsanaWebhook)(input, context);
+});

package/dist/handlers/listExternalProjects.d.ts

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

package/dist/handlers/listExternalProjects.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listExternalProjects = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+const SYSTEM = 'asana';
+exports.listExternalProjects = (0, integration_sdk_1.defineHandler)(async (_input, context) => {
+    context.logger.info('Listing Asana projects', {
+        system: SYSTEM,
+        installationId: context.installationId
+    });
+    const client = (0, taskSync_1.createAsanaClient)(context);
+    return await client.listProjects();
+});

package/dist/handlers/runFullSync.d.ts

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

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 Asana full sync', {
+        installationId: context.installationId,
+        syncDirection: context.config?.syncDirection ?? 'bidirectional'
+    });
+    return await (0, taskSync_1.runAsanaFullSync)(context);
+});

package/dist/handlers/syncTaskFromExternal.d.ts

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

package/dist/handlers/syncTaskFromExternal.js

@@ -0,0 +1,15 @@
+"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) => {
+    // For Asana, inbound task/time-entry events flow through the same webhook
+    // pipeline — there's no first-class "fetch one entry" entry-point that's
+    // different from a generic webhook invocation.
+    context.logger.info('Syncing from Asana payload (legacy entry point)', {
+        installationId: context.installationId,
+        externalTaskId: input?.externalTaskId
+    });
+    return await (0, taskSync_1.handleAsanaWebhook)(input, context);
+});

package/dist/handlers/syncTaskToExternal.d.ts

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

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 Timesheet task → Asana time entry', {
+        installationId: context.installationId,
+        taskId: input?.taskId ?? input?.item?.id,
+        event: input?.event
+    });
+    return await (0, taskSync_1.syncTimesheetTaskToAsana)(input, context);
+});

package/dist/handlers/syncTodoFromExternal.d.ts

@@ -0,0 +1,3 @@
+import { AsanaConfig, SyncInput } from '../lib/types';
+import { AsanaSyncResult } from '../lib/taskSync';
+export declare const syncTodoFromExternal: import("@timesheet/integration-sdk").IntegrationHandler<SyncInput, AsanaSyncResult, AsanaConfig>;

package/dist/handlers/syncTodoFromExternal.js

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

package/dist/handlers/syncTodoToExternal.d.ts

@@ -0,0 +1,3 @@
+import { AsanaConfig, SyncInput } from '../lib/types';
+import { AsanaSyncResult } from '../lib/taskSync';
+export declare const syncTodoToExternal: import("@timesheet/integration-sdk").IntegrationHandler<SyncInput, AsanaSyncResult, AsanaConfig>;

package/dist/handlers/syncTodoToExternal.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncTodoToExternal = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+exports.syncTodoToExternal = (0, integration_sdk_1.defineHandler)(async (input, context) => {
+    context.logger.info('Syncing Timesheet todo → Asana task', {
+        installationId: context.installationId,
+        todoId: input?.entityId ?? input?.item?.id,
+        event: input?.event
+    });
+    return await (0, taskSync_1.syncTodoToAsana)(input, context);
+});

package/dist/handlers/testConnection.d.ts

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

package/dist/handlers/testConnection.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testConnection = void 0;
+const integration_sdk_1 = require("@timesheet/integration-sdk");
+const taskSync_1 = require("../lib/taskSync");
+const SYSTEM = 'asana';
+exports.testConnection = (0, integration_sdk_1.defineHandler)(async (_input, context) => {
+    context.logger.info('Testing Asana connection', {
+        system: SYSTEM,
+        installationId: context.installationId
+    });
+    const client = (0, taskSync_1.createAsanaClient)(context);
+    const ok = await client.testConnection();
+    return {
+        system: SYSTEM,
+        ok,
+        installationId: context.installationId
+    };
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { syncTaskToExternal } from './handlers/syncTaskToExternal';
+export { syncTaskFromExternal } from './handlers/syncTaskFromExternal';
+export { syncTodoToExternal } from './handlers/syncTodoToExternal';
+export { syncTodoFromExternal } from './handlers/syncTodoFromExternal';
+export { handleSyncBatch } from './handlers/handleSyncBatch';
+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 = "asana";
+export declare const PLUGIN_NAME = "Asana Sync";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_NAME = exports.PLUGIN_SYSTEM = exports.listExternalProjects = exports.testConnection = exports.runFullSync = exports.handleWebhook = exports.handleSyncBatch = exports.syncTodoFromExternal = exports.syncTodoToExternal = 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 syncTodoToExternal_1 = require("./handlers/syncTodoToExternal");
+Object.defineProperty(exports, "syncTodoToExternal", { enumerable: true, get: function () { return syncTodoToExternal_1.syncTodoToExternal; } });
+var syncTodoFromExternal_1 = require("./handlers/syncTodoFromExternal");
+Object.defineProperty(exports, "syncTodoFromExternal", { enumerable: true, get: function () { return syncTodoFromExternal_1.syncTodoFromExternal; } });
+var handleSyncBatch_1 = require("./handlers/handleSyncBatch");
+Object.defineProperty(exports, "handleSyncBatch", { enumerable: true, get: function () { return handleSyncBatch_1.handleSyncBatch; } });
+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 = 'asana';
+exports.PLUGIN_NAME = 'Asana Sync';

package/dist/lib/asanaClient.d.ts

@@ -0,0 +1,46 @@
+import { ExternalEntity } from '@timesheet/integration-sdk';
+import { AsanaTask, AsanaTimeTrackingEntry } from './types';
+interface AsanaClientOptions {
+    getAccessToken: () => Promise<string>;
+    refreshAccessToken: () => Promise<string>;
+    workspaceId?: string;
+}
+export declare class AsanaClient {
+    private static readonly BASE_URL;
+    private static readonly REQUEST_TIMEOUT_MS;
+    private static readonly PAGE_LIMIT;
+    private readonly fetchAccessToken;
+    private readonly fetchRefreshedToken;
+    private cachedToken;
+    private readonly workspaceId;
+    constructor(options: AsanaClientOptions);
+    testConnection(): Promise<boolean>;
+    listWorkspaces(): Promise<ExternalEntity[]>;
+    listProjects(): Promise<ExternalEntity[]>;
+    listTasksInProject(projectId: string, modifiedSinceIso?: string): Promise<AsanaTask[]>;
+    getTask(taskId: string): Promise<AsanaTask | null>;
+    createTask(payload: Record<string, unknown>): Promise<AsanaTask>;
+    updateTask(taskId: string, payload: Record<string, unknown>): Promise<AsanaTask>;
+    deleteTask(taskId: string): Promise<void>;
+    listTimeTrackingEntries(taskId: string): Promise<AsanaTimeTrackingEntry[]>;
+    getTimeTrackingEntry(entryId: string): Promise<AsanaTimeTrackingEntry | null>;
+    createTimeTrackingEntry(taskId: string, payload: {
+        duration_minutes: number;
+        entered_on: string;
+    }): Promise<AsanaTimeTrackingEntry>;
+    updateTimeTrackingEntry(entryId: string, payload: Partial<{
+        duration_minutes: number;
+        entered_on: string;
+    }>): Promise<AsanaTimeTrackingEntry>;
+    deleteTimeTrackingEntry(entryId: string): Promise<void>;
+    createWebhook(resourceId: string, targetUrl: string): Promise<{
+        gid: string;
+    }>;
+    deleteWebhook(webhookGid: string): Promise<void>;
+    private paginate;
+    private getAccessToken;
+    private refreshAccessToken;
+    private request;
+    private buildUrl;
+}
+export {};

package/dist/lib/asanaClient.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsanaClient = void 0;
+class AsanaClient {
+    constructor(options) {
+        this.cachedToken = null;
+        this.fetchAccessToken = options.getAccessToken;
+        this.fetchRefreshedToken = options.refreshAccessToken;
+        this.workspaceId = options.workspaceId;
+    }
+    async testConnection() {
+        const me = await this.request('GET', '/users/me');
+        return !!me?.data?.gid;
+    }
+    async listWorkspaces() {
+        const workspaces = await this.paginate('/workspaces', {
+            opt_fields: 'name'
+        });
+        return workspaces.map((ws) => ({
+            id: ws.gid,
+            name: ws.name ?? ws.gid
+        }));
+    }
+    async listProjects() {
+        // If a workspace is configured, scope projects to it; otherwise list
+        // projects across all workspaces the token can see.
+        const workspaceIds = this.workspaceId
+            ? [this.workspaceId]
+            : (await this.listWorkspaces()).map((ws) => ws.id);
+        const out = [];
+        for (const wsId of workspaceIds) {
+            const projects = await this.paginate('/projects', {
+                workspace: wsId,
+                archived: 'false',
+                opt_fields: 'name,archived,workspace.name'
+            });
+            for (const project of projects) {
+                if (!project.gid)
+                    continue;
+                const workspaceName = project.workspace?.name;
+                out.push({
+                    id: project.gid,
+                    name: workspaceName ? `${workspaceName} / ${project.name ?? project.gid}` : project.name ?? project.gid,
+                    workspaceId: project.workspace?.gid ?? wsId,
+                    archived: project.archived ?? false
+                });
+            }
+        }
+        return out;
+    }
+    async listTasksInProject(projectId, modifiedSinceIso) {
+        const query = {
+            opt_fields: 'name,notes,completed,completed_at,created_at,modified_at,due_at,due_on,start_at,start_on,assignee.gid,projects.gid,workspace.gid'
+        };
+        if (modifiedSinceIso) {
+            query.modified_since = modifiedSinceIso;
+        }
+        return this.paginate(`/projects/${encodeURIComponent(projectId)}/tasks`, query);
+    }
+    async getTask(taskId) {
+        try {
+            const response = await this.request('GET', `/tasks/${encodeURIComponent(taskId)}`, {
+                opt_fields: 'name,notes,completed,completed_at,created_at,modified_at,due_at,due_on,start_at,start_on,assignee.gid,projects.gid,workspace.gid'
+            });
+            return response?.data ?? null;
+        }
+        catch (err) {
+            if (String(err).includes('(404)')) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async createTask(payload) {
+        const response = await this.request('POST', '/tasks', undefined, { data: payload });
+        if (!response?.data?.gid) {
+            throw new Error('Asana createTask did not return a task gid.');
+        }
+        return response.data;
+    }
+    async updateTask(taskId, payload) {
+        const response = await this.request('PUT', `/tasks/${encodeURIComponent(taskId)}`, undefined, { data: payload });
+        if (!response?.data?.gid) {
+            throw new Error('Asana updateTask did not return a task gid.');
+        }
+        return response.data;
+    }
+    async deleteTask(taskId) {
+        await this.request('DELETE', `/tasks/${encodeURIComponent(taskId)}`);
+    }
+    async listTimeTrackingEntries(taskId) {
+        return this.paginate(`/tasks/${encodeURIComponent(taskId)}/time_tracking_entries`, { opt_fields: 'duration_minutes,entered_on,created_at,created_by.gid,task.gid' });
+    }
+    async getTimeTrackingEntry(entryId) {
+        try {
+            const response = await this.request('GET', `/time_tracking_entries/${encodeURIComponent(entryId)}`, { opt_fields: 'duration_minutes,entered_on,created_at,created_by.gid,task.gid' });
+            return response?.data ?? null;
+        }
+        catch (err) {
+            if (String(err).includes('(404)')) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async createTimeTrackingEntry(taskId, payload) {
+        const response = await this.request('POST', `/tasks/${encodeURIComponent(taskId)}/time_tracking_entries`, undefined, { data: payload });
+        if (!response?.data?.gid) {
+            throw new Error('Asana createTimeTrackingEntry did not return a gid.');
+        }
+        return response.data;
+    }
+    async updateTimeTrackingEntry(entryId, payload) {
+        const response = await this.request('PUT', `/time_tracking_entries/${encodeURIComponent(entryId)}`, undefined, { data: payload });
+        if (!response?.data?.gid) {
+            throw new Error('Asana updateTimeTrackingEntry did not return a gid.');
+        }
+        return response.data;
+    }
+    async deleteTimeTrackingEntry(entryId) {
+        await this.request('DELETE', `/time_tracking_entries/${encodeURIComponent(entryId)}`);
+    }
+    async createWebhook(resourceId, targetUrl) {
+        const response = await this.request('POST', '/webhooks', undefined, {
+            data: {
+                resource: resourceId,
+                target: targetUrl
+            }
+        });
+        if (!response?.data?.gid) {
+            throw new Error('Asana createWebhook did not return a webhook gid.');
+        }
+        return response.data;
+    }
+    async deleteWebhook(webhookGid) {
+        try {
+            await this.request('DELETE', `/webhooks/${encodeURIComponent(webhookGid)}`);
+        }
+        catch (err) {
+            // 404 means the hook was already cleaned up — not an error.
+            if (!String(err).includes('(404)')) {
+                throw err;
+            }
+        }
+    }
+    async paginate(path, baseQuery) {
+        const out = [];
+        let offset;
+        do {
+            const query = { ...baseQuery, limit: String(AsanaClient.PAGE_LIMIT) };
+            if (offset) {
+                query.offset = offset;
+            }
+            const response = await this.request('GET', path, query);
+            if (response?.data?.length) {
+                out.push(...response.data);
+            }
+            offset = response?.next_page?.offset ?? undefined;
+        } while (offset);
+        return out;
+    }
+    async getAccessToken() {
+        if (this.cachedToken) {
+            return this.cachedToken;
+        }
+        this.cachedToken = await this.fetchAccessToken();
+        return this.cachedToken;
+    }
+    async refreshAccessToken() {
+        this.cachedToken = null;
+        this.cachedToken = await this.fetchRefreshedToken();
+        return this.cachedToken;
+    }
+    async request(method, path, query, body, retried = false) {
+        const token = await this.getAccessToken();
+        const url = this.buildUrl(path, query);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), AsanaClient.REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(url, {
+                method,
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: controller.signal
+            });
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw new Error(`Asana API ${method} ${path} timed out after ${AsanaClient.REQUEST_TIMEOUT_MS}ms`);
+            }
+            throw error;
+        }
+        clearTimeout(timeoutId);
+        if (response.status === 401 && !retried) {
+            const refreshed = await this.refreshAccessToken();
+            if (refreshed) {
+                return this.request(method, path, query, body, true);
+            }
+        }
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`Asana API ${method} ${path} failed (${response.status}): ${errorBody}`);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return (await response.json());
+    }
+    buildUrl(path, query) {
+        const url = new URL(`${AsanaClient.BASE_URL}${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.AsanaClient = AsanaClient;
+AsanaClient.BASE_URL = 'https://app.asana.com/api/1.0';
+AsanaClient.REQUEST_TIMEOUT_MS = 30000;
+AsanaClient.PAGE_LIMIT = 100;

package/dist/lib/taskSync.d.ts

@@ -0,0 +1,21 @@
+import { IntegrationContext, MappingRecord } from '@timesheet/integration-sdk';
+import { AsanaClient } from './asanaClient';
+import { AsanaConfig, SyncInput } from './types';
+export interface AsanaSyncResult {
+    system: string;
+    status: string;
+    syncedCount: number;
+    details?: Record<string, unknown>;
+}
+export interface SyncBatchCaches {
+    projectMappingByLocalId?: Map<string, MappingRecord>;
+    todoMappingByLocalId?: Map<string, MappingRecord>;
+    taskMappingByLocalId?: Map<string, MappingRecord>;
+}
+export declare function resetSharedClient(): void;
+export declare function createAsanaClient(context: IntegrationContext<AsanaConfig>): AsanaClient;
+export declare function syncTodoToAsana(input: SyncInput, context: IntegrationContext<AsanaConfig>, caches?: SyncBatchCaches): Promise<AsanaSyncResult>;
+export declare function syncTimesheetTaskToAsana(input: SyncInput, context: IntegrationContext<AsanaConfig>, caches?: SyncBatchCaches): Promise<AsanaSyncResult>;
+export declare function runAsanaFullSync(context: IntegrationContext<AsanaConfig>): Promise<AsanaSyncResult>;
+export declare function handleAsanaWebhook(input: SyncInput, context: IntegrationContext<AsanaConfig>): Promise<AsanaSyncResult>;
+export declare function syncTodoFromAsana(input: SyncInput, context: IntegrationContext<AsanaConfig>): Promise<AsanaSyncResult>;