@terminai/a2a-server 0.21.0

package/dist/src/index.js

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Portions Copyright 2025 TerminaI Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from './agent/executor.js';
+export * from './http/app.js';
+export * from './persistence/remoteAuthStore.js';
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,YAAY,CAAC"}

package/dist/src/persistence/gcs.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Portions Copyright 2025 TerminaI Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Task as SDKTask } from '@a2a-js/sdk';
+import type { TaskStore } from '@a2a-js/sdk/server';
+export declare class GCSTaskStore implements TaskStore {
+    private storage;
+    private bucketName;
+    private bucketInitialized;
+    constructor(bucketName: string);
+    private initializeBucket;
+    private ensureBucketInitialized;
+    private getObjectPath;
+    save(task: SDKTask): Promise<void>;
+    load(taskId: string): Promise<SDKTask | undefined>;
+}
+export declare class NoOpTaskStore implements TaskStore {
+    private realStore;
+    constructor(realStore: TaskStore);
+    save(task: SDKTask): Promise<void>;
+    load(taskId: string): Promise<SDKTask | undefined>;
+}

package/dist/src/persistence/gcs.js

@@ -0,0 +1,248 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Portions Copyright 2025 TerminaI Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Storage } from '@google-cloud/storage';
+import { gzipSync, gunzipSync } from 'node:zlib';
+import * as tar from 'tar';
+import * as fse from 'fs-extra';
+import { promises as fsPromises, createReadStream } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { setTargetDir } from '../config/config.js';
+import { getPersistedState } from '../types.js';
+import { v4 as uuidv4 } from 'uuid';
+const getTmpArchiveFilename = (taskId) => `task-${taskId}-workspace-${uuidv4()}.tar.gz`;
+// Validate the taskId to prevent path traversal attacks by ensuring it only contains safe characters.
+const isTaskIdValid = (taskId) => {
+    // Allow only alphanumeric characters, dashes, and underscores, and ensure it's not empty.
+    const validTaskIdRegex = /^[a-zA-Z0-9_-]+$/;
+    return validTaskIdRegex.test(taskId);
+};
+export class GCSTaskStore {
+    storage;
+    bucketName;
+    bucketInitialized;
+    constructor(bucketName) {
+        if (!bucketName) {
+            throw new Error('GCS bucket name is required.');
+        }
+        this.storage = new Storage();
+        this.bucketName = bucketName;
+        logger.info(`GCSTaskStore initializing with bucket: ${this.bucketName}`);
+        // Prerequisites: user account or service account must have storage admin IAM role
+        // and the bucket name must be unique.
+        this.bucketInitialized = this.initializeBucket();
+    }
+    async initializeBucket() {
+        try {
+            const [buckets] = await this.storage.getBuckets();
+            const exists = buckets.some((bucket) => bucket.name === this.bucketName);
+            if (!exists) {
+                logger.info(`Bucket ${this.bucketName} does not exist in the list. Attempting to create...`);
+                try {
+                    await this.storage.createBucket(this.bucketName);
+                    logger.info(`Bucket ${this.bucketName} created successfully.`);
+                }
+                catch (createError) {
+                    logger.info(`Failed to create bucket ${this.bucketName}: ${createError}`);
+                    throw new Error(`Failed to create GCS bucket ${this.bucketName}: ${createError}`);
+                }
+            }
+            else {
+                logger.info(`Bucket ${this.bucketName} exists.`);
+            }
+        }
+        catch (error) {
+            logger.info(`Error during bucket initialization for ${this.bucketName}: ${error}`);
+            throw new Error(`Failed to initialize GCS bucket ${this.bucketName}: ${error}`);
+        }
+    }
+    async ensureBucketInitialized() {
+        await this.bucketInitialized;
+    }
+    getObjectPath(taskId, type) {
+        if (!isTaskIdValid(taskId)) {
+            throw new Error(`Invalid taskId: ${taskId}`);
+        }
+        return `tasks/${taskId}/${type}.tar.gz`;
+    }
+    async save(task) {
+        await this.ensureBucketInitialized();
+        const taskId = task.id;
+        const persistedState = getPersistedState(task.metadata);
+        if (!persistedState) {
+            throw new Error(`Task ${taskId} is missing persisted state in metadata.`);
+        }
+        const workDir = process.cwd();
+        const metadataObjectPath = this.getObjectPath(taskId, 'metadata');
+        const workspaceObjectPath = this.getObjectPath(taskId, 'workspace');
+        const dataToStore = task.metadata;
+        try {
+            const jsonString = JSON.stringify(dataToStore);
+            const compressedMetadata = gzipSync(Buffer.from(jsonString));
+            const metadataFile = this.storage
+                .bucket(this.bucketName)
+                .file(metadataObjectPath);
+            await metadataFile.save(compressedMetadata, {
+                contentType: 'application/gzip',
+            });
+            logger.info(`Task ${taskId} metadata saved to GCS: gs://${this.bucketName}/${metadataObjectPath}`);
+            if (await fse.pathExists(workDir)) {
+                const entries = await fsPromises.readdir(workDir);
+                if (entries.length > 0) {
+                    const tmpArchiveFile = join(tmpdir(), getTmpArchiveFilename(taskId));
+                    try {
+                        await tar.c({
+                            gzip: true,
+                            file: tmpArchiveFile,
+                            cwd: workDir,
+                            portable: true,
+                        }, entries);
+                        if (!(await fse.pathExists(tmpArchiveFile))) {
+                            throw new Error(`tar.c command failed to create ${tmpArchiveFile}`);
+                        }
+                        const workspaceFile = this.storage
+                            .bucket(this.bucketName)
+                            .file(workspaceObjectPath);
+                        const sourceStream = createReadStream(tmpArchiveFile);
+                        const destStream = workspaceFile.createWriteStream({
+                            contentType: 'application/gzip',
+                            resumable: true,
+                        });
+                        await new Promise((resolve, reject) => {
+                            sourceStream.on('error', (err) => {
+                                logger.error(`Error in source stream for ${tmpArchiveFile}:`, err);
+                                // Attempt to close destStream if source fails
+                                if (!destStream.destroyed) {
+                                    destStream.destroy(err);
+                                }
+                                reject(err);
+                            });
+                            destStream.on('error', (err) => {
+                                logger.error(`Error in GCS dest stream for ${workspaceObjectPath}:`, err);
+                                reject(err);
+                            });
+                            destStream.on('finish', () => {
+                                logger.info(`GCS destStream finished for ${workspaceObjectPath}`);
+                                resolve();
+                            });
+                            logger.info(`Piping ${tmpArchiveFile} to GCS object ${workspaceObjectPath}`);
+                            sourceStream.pipe(destStream);
+                        });
+                        logger.info(`Task ${taskId} workspace saved to GCS: gs://${this.bucketName}/${workspaceObjectPath}`);
+                    }
+                    catch (error) {
+                        logger.error(`Error during workspace save process for ${taskId}:`, error);
+                        throw error;
+                    }
+                    finally {
+                        logger.info(`Cleaning up temporary file: ${tmpArchiveFile}`);
+                        try {
+                            if (await fse.pathExists(tmpArchiveFile)) {
+                                await fse.remove(tmpArchiveFile);
+                                logger.info(`Successfully removed temporary file: ${tmpArchiveFile}`);
+                            }
+                            else {
+                                logger.warn(`Temporary file not found for cleanup: ${tmpArchiveFile}`);
+                            }
+                        }
+                        catch (removeError) {
+                            logger.error(`Error removing temporary file ${tmpArchiveFile}:`, removeError);
+                        }
+                    }
+                }
+                else {
+                    logger.info(`Workspace directory ${workDir} is empty, skipping workspace save for task ${taskId}.`);
+                }
+            }
+            else {
+                logger.info(`Workspace directory ${workDir} not found, skipping workspace save for task ${taskId}.`);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to save task ${taskId} to GCS:`, error);
+            throw error;
+        }
+    }
+    async load(taskId) {
+        await this.ensureBucketInitialized();
+        const metadataObjectPath = this.getObjectPath(taskId, 'metadata');
+        const workspaceObjectPath = this.getObjectPath(taskId, 'workspace');
+        try {
+            const metadataFile = this.storage
+                .bucket(this.bucketName)
+                .file(metadataObjectPath);
+            const [metadataExists] = await metadataFile.exists();
+            if (!metadataExists) {
+                logger.info(`Task ${taskId} metadata not found in GCS.`);
+                return undefined;
+            }
+            const [compressedMetadata] = await metadataFile.download();
+            const jsonData = gunzipSync(compressedMetadata).toString();
+            const loadedMetadata = JSON.parse(jsonData);
+            logger.info(`Task ${taskId} metadata loaded from GCS.`);
+            const persistedState = getPersistedState(loadedMetadata);
+            if (!persistedState) {
+                throw new Error(`Loaded metadata for task ${taskId} is missing internal persisted state.`);
+            }
+            const agentSettings = persistedState._agentSettings;
+            const workDir = setTargetDir(agentSettings);
+            await fse.ensureDir(workDir);
+            const workspaceFile = this.storage
+                .bucket(this.bucketName)
+                .file(workspaceObjectPath);
+            const [workspaceExists] = await workspaceFile.exists();
+            if (workspaceExists) {
+                const tmpArchiveFile = join(tmpdir(), getTmpArchiveFilename(taskId));
+                try {
+                    await workspaceFile.download({ destination: tmpArchiveFile });
+                    await tar.x({ file: tmpArchiveFile, cwd: workDir });
+                    logger.info(`Task ${taskId} workspace restored from GCS to ${workDir}`);
+                }
+                finally {
+                    if (await fse.pathExists(tmpArchiveFile)) {
+                        await fse.remove(tmpArchiveFile);
+                    }
+                }
+            }
+            else {
+                logger.info(`Task ${taskId} workspace archive not found in GCS.`);
+            }
+            return {
+                id: taskId,
+                contextId: loadedMetadata._contextId || uuidv4(),
+                kind: 'task',
+                status: {
+                    state: persistedState._taskState,
+                    timestamp: new Date().toISOString(),
+                },
+                metadata: loadedMetadata,
+                history: [],
+                artifacts: [],
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to load task ${taskId} from GCS:`, error);
+            throw error;
+        }
+    }
+}
+export class NoOpTaskStore {
+    realStore;
+    constructor(realStore) {
+        this.realStore = realStore;
+    }
+    async save(task) {
+        logger.info(`[NoOpTaskStore] save called for task ${task.id} - IGNORED`);
+        return Promise.resolve();
+    }
+    async load(taskId) {
+        logger.info(`[NoOpTaskStore] load called for task ${taskId}, delegating to real store.`);
+        return this.realStore.load(taskId);
+    }
+}
+//# sourceMappingURL=gcs.js.map

package/dist/src/persistence/gcs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcs.js","sourceRoot":"","sources":["../../../src/persistence/gcs.ts"],"names":[],"mappings":"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"}

package/dist/src/persistence/gcs.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Portions Copyright 2025 TerminaI Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/persistence/gcs.test.js

@@ -0,0 +1,335 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Portions Copyright 2025 TerminaI Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Storage } from '@google-cloud/storage';
+import * as fse from 'fs-extra';
+import * as tar from 'tar';
+import { gzipSync, gunzipSync } from 'node:zlib';
+import { v4 as uuidv4 } from 'uuid';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { GCSTaskStore, NoOpTaskStore } from './gcs.js';
+import { logger } from '../utils/logger.js';
+import * as configModule from '../config/config.js';
+import { getPersistedState, METADATA_KEY } from '../types.js';
+// Mock dependencies
+const fsMocks = vi.hoisted(() => ({
+    readdir: vi.fn(),
+    createReadStream: vi.fn(),
+}));
+vi.mock('@google-cloud/storage');
+vi.mock('fs-extra', () => ({
+    pathExists: vi.fn(),
+    readdir: vi.fn(),
+    remove: vi.fn(),
+    ensureDir: vi.fn(),
+    createReadStream: vi.fn(),
+}));
+vi.mock('node:fs', async () => {
+    const actual = await vi.importActual('node:fs');
+    return {
+        ...actual,
+        promises: {
+            ...actual.promises,
+            readdir: fsMocks.readdir,
+        },
+        createReadStream: fsMocks.createReadStream,
+    };
+});
+vi.mock('fs', async () => {
+    const actual = await vi.importActual('node:fs');
+    return {
+        ...actual,
+        promises: {
+            ...actual.promises,
+            readdir: fsMocks.readdir,
+        },
+        createReadStream: fsMocks.createReadStream,
+    };
+});
+vi.mock('tar', async () => {
+    const actualFs = await vi.importActual('node:fs');
+    return {
+        c: vi.fn(({ file }) => {
+            if (file) {
+                actualFs.writeFileSync(file, Buffer.from('dummy tar content'));
+            }
+            return Promise.resolve();
+        }),
+        x: vi.fn().mockResolvedValue(undefined),
+        t: vi.fn().mockResolvedValue(undefined),
+        r: vi.fn().mockResolvedValue(undefined),
+        u: vi.fn().mockResolvedValue(undefined),
+    };
+});
+vi.mock('zlib');
+vi.mock('uuid');
+vi.mock('../utils/logger.js', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('../config/config.js', () => ({
+    setTargetDir: vi.fn(),
+}));
+vi.mock('node:stream/promises', () => ({
+    pipeline: vi.fn(),
+}));
+vi.mock('../types.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getPersistedState: vi.fn(),
+    };
+});
+const mockStorage = Storage;
+const mockFse = fse;
+const mockCreateReadStream = fsMocks.createReadStream;
+const mockTar = tar;
+const mockGzipSync = gzipSync;
+const mockGunzipSync = gunzipSync;
+const mockUuidv4 = uuidv4;
+const mockSetTargetDir = configModule.setTargetDir;
+const mockGetPersistedState = getPersistedState;
+const TEST_METADATA_KEY = METADATA_KEY || '__persistedState';
+describe('GCSTaskStore', () => {
+    let bucketName;
+    let mockBucket;
+    let mockFile;
+    let mockWriteStream;
+    let mockStorageInstance;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        bucketName = 'test-bucket';
+        mockWriteStream = {
+            emit: vi.fn().mockReturnValue(true),
+            removeListener: vi.fn().mockReturnValue(mockWriteStream),
+            on: vi.fn((event, cb) => {
+                if (event === 'finish')
+                    setTimeout(cb, 0); // Simulate async finish
+                return mockWriteStream;
+            }),
+            once: vi.fn((event, cb) => {
+                if (event === 'finish')
+                    setTimeout(cb, 0); // Simulate async finish        return mockWriteStream;
+            }),
+            destroy: vi.fn(),
+            write: vi.fn().mockReturnValue(true),
+            end: vi.fn(),
+            destroyed: false,
+        };
+        mockFile = {
+            save: vi.fn().mockResolvedValue(undefined),
+            download: vi.fn().mockResolvedValue([Buffer.from('')]),
+            exists: vi.fn().mockResolvedValue([true]),
+            createWriteStream: vi.fn().mockReturnValue(mockWriteStream),
+        };
+        mockBucket = {
+            exists: vi.fn().mockResolvedValue([true]),
+            file: vi.fn().mockReturnValue(mockFile),
+            name: bucketName,
+        };
+        mockStorageInstance = {
+            bucket: vi.fn().mockReturnValue(mockBucket),
+            getBuckets: vi.fn().mockResolvedValue([[{ name: bucketName }]]),
+            createBucket: vi.fn().mockResolvedValue([mockBucket]),
+        };
+        mockStorage.mockReturnValue(mockStorageInstance);
+        mockUuidv4.mockReturnValue('test-uuid');
+        mockSetTargetDir.mockReturnValue('/tmp/workdir');
+        mockGetPersistedState.mockReturnValue({
+            _agentSettings: {},
+            _taskState: 'submitted',
+        });
+        fse.pathExists.mockResolvedValue(true);
+        fsMocks.readdir.mockResolvedValue(['file1.txt']);
+        mockFse.remove.mockResolvedValue(undefined);
+        mockFse.ensureDir.mockResolvedValue(undefined);
+        mockGzipSync.mockReturnValue(Buffer.from('compressed'));
+        mockGunzipSync.mockReturnValue(Buffer.from('{}'));
+        mockCreateReadStream.mockReturnValue({ on: vi.fn(), pipe: vi.fn() });
+        mockFse.createReadStream.mockReturnValue({
+            on: vi.fn(),
+            pipe: vi.fn(),
+        });
+    });
+    describe('Constructor & Initialization', () => {
+        it('should initialize and check bucket existence', async () => {
+            const store = new GCSTaskStore(bucketName);
+            await store['ensureBucketInitialized']();
+            expect(mockStorage).toHaveBeenCalledTimes(1);
+            expect(mockStorageInstance.getBuckets).toHaveBeenCalled();
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Bucket test-bucket exists'));
+        });
+        it('should create bucket if it does not exist', async () => {
+            mockStorageInstance.getBuckets.mockResolvedValue([[]]);
+            const store = new GCSTaskStore(bucketName);
+            await store['ensureBucketInitialized']();
+            expect(mockStorageInstance.createBucket).toHaveBeenCalledWith(bucketName);
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Bucket test-bucket created successfully'));
+        });
+        it('should throw if bucket creation fails', async () => {
+            mockStorageInstance.getBuckets.mockResolvedValue([[]]);
+            mockStorageInstance.createBucket.mockRejectedValue(new Error('Create failed'));
+            const store = new GCSTaskStore(bucketName);
+            await expect(store['ensureBucketInitialized']()).rejects.toThrow('Failed to create GCS bucket test-bucket: Error: Create failed');
+        });
+    });
+    describe('save', () => {
+        const mockTask = {
+            id: 'task1',
+            contextId: 'ctx1',
+            kind: 'task',
+            status: { state: 'working' },
+            metadata: {},
+        };
+        it('should save metadata and workspace', async () => {
+            const store = new GCSTaskStore(bucketName);
+            await store.save(mockTask);
+            expect(mockFile.save).toHaveBeenCalledTimes(1);
+            expect(mockTar.c).toHaveBeenCalledTimes(1);
+            expect(mockFse.remove).toHaveBeenCalledTimes(1);
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('metadata saved to GCS'));
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('workspace saved to GCS'));
+        });
+        it('should handle tar creation failure', async () => {
+            mockFse.pathExists.mockImplementation(async (path) => !path.toString().includes('task-task1-workspace-test-uuid.tar.gz'));
+            const store = new GCSTaskStore(bucketName);
+            await expect(store.save(mockTask)).rejects.toThrow('tar.c command failed to create');
+        });
+        it('should throw an error if taskId contains path traversal sequences', async () => {
+            const store = new GCSTaskStore('test-bucket');
+            const maliciousTask = {
+                id: '../../../malicious-task',
+                metadata: {
+                    _internal: {
+                        agentSettings: {
+                            cacheDir: '/tmp/cache',
+                            dataDir: '/tmp/data',
+                            logDir: '/tmp/logs',
+                            tempDir: '/tmp/temp',
+                        },
+                        taskState: 'working',
+                    },
+                },
+                kind: 'task',
+                status: {
+                    state: 'working',
+                    timestamp: new Date().toISOString(),
+                },
+                contextId: 'test-context',
+                history: [],
+                artifacts: [],
+            };
+            await expect(store.save(maliciousTask)).rejects.toThrow('Invalid taskId: ../../../malicious-task');
+        });
+    });
+    describe('load', () => {
+        it('should load task metadata and workspace', async () => {
+            mockGunzipSync.mockReturnValue(Buffer.from(JSON.stringify({
+                [TEST_METADATA_KEY]: {
+                    _agentSettings: {},
+                    _taskState: 'submitted',
+                },
+                _contextId: 'ctx1',
+            })));
+            mockFile.download.mockResolvedValue([Buffer.from('compressed metadata')]);
+            mockFile.download.mockResolvedValueOnce([
+                Buffer.from('compressed metadata'),
+            ]);
+            mockBucket.file = vi.fn((path) => {
+                const newMockFile = { ...mockFile };
+                if (path.includes('metadata')) {
+                    newMockFile.download = vi
+                        .fn()
+                        .mockResolvedValue([Buffer.from('compressed metadata')]);
+                    newMockFile.exists = vi.fn().mockResolvedValue([true]);
+                }
+                else {
+                    newMockFile.download = vi
+                        .fn()
+                        .mockResolvedValue([Buffer.from('compressed workspace')]);
+                    newMockFile.exists = vi.fn().mockResolvedValue([true]);
+                }
+                return newMockFile;
+            });
+            const store = new GCSTaskStore(bucketName);
+            const task = await store.load('task1');
+            expect(task).toBeDefined();
+            expect(task?.id).toBe('task1');
+            expect(mockBucket.file).toHaveBeenCalledWith('tasks/task1/metadata.tar.gz');
+            expect(mockBucket.file).toHaveBeenCalledWith('tasks/task1/workspace.tar.gz');
+            expect(mockTar.x).toHaveBeenCalledTimes(1);
+            expect(mockFse.remove).toHaveBeenCalledTimes(1);
+        });
+        it('should return undefined if metadata not found', async () => {
+            mockFile.exists.mockResolvedValue([false]);
+            const store = new GCSTaskStore(bucketName);
+            const task = await store.load('task1');
+            expect(task).toBeUndefined();
+            expect(mockBucket.file).toHaveBeenCalledWith('tasks/task1/metadata.tar.gz');
+        });
+        it('should load metadata even if workspace not found', async () => {
+            mockGunzipSync.mockReturnValue(Buffer.from(JSON.stringify({
+                [TEST_METADATA_KEY]: {
+                    _agentSettings: {},
+                    _taskState: 'submitted',
+                },
+                _contextId: 'ctx1',
+            })));
+            mockBucket.file = vi.fn((path) => {
+                const newMockFile = { ...mockFile };
+                if (path.includes('workspace.tar.gz')) {
+                    newMockFile.exists = vi.fn().mockResolvedValue([false]);
+                }
+                else {
+                    newMockFile.exists = vi.fn().mockResolvedValue([true]);
+                    newMockFile.download = vi
+                        .fn()
+                        .mockResolvedValue([Buffer.from('compressed metadata')]);
+                }
+                return newMockFile;
+            });
+            const store = new GCSTaskStore(bucketName);
+            const task = await store.load('task1');
+            expect(task).toBeDefined();
+            expect(mockTar.x).not.toHaveBeenCalled();
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('workspace archive not found'));
+        });
+    });
+    it('should throw an error if taskId contains path traversal sequences', async () => {
+        const store = new GCSTaskStore('test-bucket');
+        const maliciousTaskId = '../../../malicious-task';
+        await expect(store.load(maliciousTaskId)).rejects.toThrow(`Invalid taskId: ${maliciousTaskId}`);
+    });
+});
+describe('NoOpTaskStore', () => {
+    let realStore;
+    let noOpStore;
+    beforeEach(() => {
+        // Create a mock of the real store to delegate to
+        realStore = {
+            save: vi.fn(),
+            load: vi.fn().mockResolvedValue({ id: 'task-123' }),
+        };
+        noOpStore = new NoOpTaskStore(realStore);
+    });
+    it("should not call the real store's save method", async () => {
+        const mockTask = { id: 'test-task' };
+        await noOpStore.save(mockTask);
+        expect(realStore.save).not.toHaveBeenCalled();
+    });
+    it('should delegate the load method to the real store', async () => {
+        const taskId = 'task-123';
+        const result = await noOpStore.load(taskId);
+        expect(realStore.load).toHaveBeenCalledWith(taskId);
+        expect(result).toBeDefined();
+        expect(result?.id).toBe(taskId);
+    });
+});
+//# sourceMappingURL=gcs.test.js.map