Feat: add Google Cloud Storage Connector

README.md

@@ -25,7 +25,7 @@ SmythOS provides a complete **Operating System for Agentic AI**. Just as traditi
 
 ### Unified Resource Abstraction
 
-SmythOS provides a **unified interface for all resources**, ensuring consistency and simplicity across your entire AI platform. Whether you're storing a file locally, on S3, or any other storage provider, you don't need to worry about the underlying implementation details. SmythOS offers a powerful abstraction layer where all providers expose the same functions and APIs.
+SmythOS provides a **unified interface for all resources**, ensuring consistency and simplicity across your entire AI platform. Whether you're storing a file locally, on S3, GCS, or any other storage provider, you don't need to worry about the underlying implementation details. SmythOS offers a powerful abstraction layer where all providers expose the same functions and APIs.
 
 This principle applies to **all services** - not just storage. Whether you're working with VectorDBs, cache (Redis, RAM), LLMs (OpenAI, Anthropic), or any other resource, the interface remains consistent across providers.
 

examples/06-Storage-no-agent/03-GCS.ts

@@ -0,0 +1,20 @@
+import { Storage } from '@smythos/sdk';
+
+async function main() {
+    const gcsStorage = Storage.GCS({
+        projectId: process.env.GCP_PROJECT_ID,
+        clientEmail: process.env.GCP_CLIENT_EMAIL,
+        privateKey: process.env.GCP_PRIVATE_KEY,
+        bucket: process.env.GCP_BUCKET_NAME,
+    });
+
+    await gcsStorage.write('test.txt', 'Hello, world!');
+
+    const data = await gcsStorage.read('test.txt');
+
+    const dataAsString = data.toString();
+
+    console.log(dataAsString);
+}
+
+main();

packages/core/docs/connectors/storage.md

@@ -81,3 +81,50 @@ SRE.init({
 -   Store credentials securely using environment variables or AWS Secrets Manager
 -   Configure appropriate bucket policies and CORS settings
 -   Enable encryption at rest and in transit for sensitive data
+
+---
+
+### GCS
+
+**Role**: Google Cloud Storage connector  
+**Summary**: Provides scalable cloud storage using Google Cloud Storage, suitable for production deployments requiring high availability and durability on Google Cloud Platform.
+
+| Setting       | Type   | Required | Default | Description                                     |
+| ------------- | ------ | -------- | ------- | ----------------------------------------------- |
+| `projectId`   | string | Yes      | -       | Google Cloud Project ID where the bucket is located |
+| `clientEmail` | string | Yes      | -       | Service account email address                   |
+| `privateKey`  | string | Yes      | -       | Service account private key                     |
+| `bucket`      | string | Yes      | -       | GCS bucket name for storing files               |
+
+**Example Configuration:**
+
+```typescript
+import { SRE } from '@smythos/sre';
+
+SRE.init({
+    Storage: {
+        Connector: 'GCS',
+        Settings: {
+            projectId: 'my-project-id',
+            clientEmail: process.env.GCP_CLIENT_EMAIL,
+            privateKey: process.env.GCP_PRIVATE_KEY,
+            bucket: 'my-app-storage',
+        },
+    },
+});
+```
+
+**Use Cases:**
+
+-   Production environments requiring scalability on Google Cloud Platform
+-   Multi-region deployments within GCP infrastructure
+-   Applications with high availability requirements
+-   Integration with Google Cloud ecosystem
+-   Large-scale data storage and processing
+
+**Security Notes:**
+
+-   Use service accounts with minimal required permissions
+-   Store credentials securely using environment variables or Google Secret Manager
+-   Configure appropriate bucket policies and IAM settings
+-   Enable encryption at rest and in transit for sensitive data

packages/core/package.json

@@ -61,6 +61,7 @@
         "@aws-sdk/client-s3": "^3.826.0",
         "@aws-sdk/client-secrets-manager": "^3.826.0",
         "@faker-js/faker": "^9.8.0",
+        "@google-cloud/storage": "^7.17.0",
         "@google-cloud/vertexai": "^1.7.0",
         "@google/genai": "^1.10.0",
         "@google/generative-ai": "^0.14.1",

packages/core/src/helpers/GCSCache.helper.ts

@@ -0,0 +1,145 @@
+import { Storage, Bucket, LifecycleRule } from '@google-cloud/storage';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const console = Logger('GCSCache');
+
+export function generateLifecycleRules(): LifecycleRule[] {
+    const rules: LifecycleRule[] = [];
+
+    // Add rules for 1-100 days
+    for (let i = 1; i < 100; i++) {
+        rules.push({
+            condition: {
+                age: i,
+                matchesSuffix: [`ExpireAfter${i}Days`]
+            },
+            action: {
+                type: 'Delete'
+            }
+        });
+    }
+
+    // Add rules for 110-1000 days with 10-day steps
+    for (let i = 100; i < 1000; i += 10) {
+        rules.push({
+            condition: {
+                age: i,
+                matchesSuffix: [`ExpireAfter${i}Days`]
+            },
+            action: {
+                type: 'Delete'
+            }
+        });
+    }
+
+    // Add rules for 1000-10000 days with 100-day steps
+    for (let i = 1000; i <= 10000; i += 100) {
+        rules.push({
+            condition: {
+                age: i,
+                matchesSuffix: [`ExpireAfter${i}Days`]
+            },
+            action: {
+                type: 'Delete'
+            }
+        });
+    }
+
+    return rules;
+}
+
+export function generateExpiryMetadata(expiryDays: number) {
+    let metadataValue: string;
+
+    if (expiryDays >= 1 && expiryDays < 100) {
+        metadataValue = `ExpireAfter${expiryDays}Days`;
+    } else if (expiryDays >= 100 && expiryDays < 1000) {
+        const roundedUpDays = Math.ceil(expiryDays / 10) * 10;
+        metadataValue = `ExpireAfter${roundedUpDays}Days`;
+    } else if (expiryDays >= 1000 && expiryDays <= 10000) {
+        const roundedUpDays = Math.ceil(expiryDays / 100) * 100;
+        metadataValue = `ExpireAfter${roundedUpDays}Days`;
+    } else {
+        throw new Error('Invalid expiry days. Please provide a valid expiry days value.');
+    }
+
+    return {
+        Key: 'expiry-tag',
+        Value: metadataValue,
+    };
+}
+
+export function getNonExistingRules(existingRules: LifecycleRule[], newRules: LifecycleRule[]): LifecycleRule[] {
+    return newRules.filter((newRule) => 
+        !existingRules.some((existingRule) => 
+            existingRule.condition.age === newRule.condition.age &&
+            JSON.stringify(existingRule.condition.matchesSuffix) === JSON.stringify(newRule.condition.matchesSuffix)
+        )
+    );
+}
+
+export function ttlToExpiryDays(ttl: number): number {
+    // seconds to days
+    return Math.ceil(ttl / (60 * 60 * 24));
+}
+
+export async function checkAndInstallLifecycleRules(bucketName: string, storage: Storage): Promise<void> {
+    // Validate inputs
+    if (!bucketName || bucketName.trim() === '') {
+        throw new Error('Bucket name is required and cannot be empty');
+    }
+
+    if (!storage) {
+        throw new Error('Storage client is required');
+    }
+
+    console.log(`Checking lifecycle rules for GCS bucket: ${bucketName}`);
+
+    try {
+        const bucket = storage.bucket(bucketName);
+
+        // Check existing lifecycle configuration
+        const [metadata] = await bucket.getMetadata();
+        const existingRules = metadata.lifecycle?.rule || [];
+
+        const newRules = generateLifecycleRules();
+        const nonExistingNewRules = getNonExistingRules(existingRules, newRules);
+
+        if (nonExistingNewRules.length > 0) {
+            const allRules = [...existingRules, ...nonExistingNewRules];
+
+            await bucket.setMetadata({
+                lifecycle: {
+                    rule: allRules
+                }
+            });
+
+            console.log(`Added ${nonExistingNewRules.length} new lifecycle rules to GCS bucket: ${bucketName}`);
+        } else {
+            console.log('Lifecycle configuration already exists');
+        }
+    } catch (error) {
+        if (error.code === 404) {
+            console.log('Bucket not found or no lifecycle configuration. Creating new configuration...');
+
+            const bucket = storage.bucket(bucketName);
+            const lifecycleRules = generateLifecycleRules();
+
+            await bucket.setMetadata({
+                lifecycle: {
+                    rule: lifecycleRules
+                }
+            });
+
+            console.log('Lifecycle configuration created successfully.');
+        } else {
+            console.error('Error checking lifecycle configuration:', error);
+            console.error('Bucket name provided:', bucketName);
+            console.error('Error details:', {
+                name: error.name,
+                message: error.message,
+                code: error.code,
+            });
+        }
+    }
+}

packages/core/src/index.ts

@@ -65,7 +65,6 @@ export * from './helpers/JsonContent.helper';
 export * from './helpers/LocalCache.helper';
 export * from './helpers/Log.helper';
 export * from './helpers/OpenApiParser.helper';
-export * from './helpers/S3Cache.helper';
 export * from './helpers/SmythURI.helper';
 export * from './helpers/Sysconfig.helper';
 export * from './helpers/TemplateString.helper';
@@ -160,6 +159,7 @@ export * from './subsystems/IO/NKV.service/connectors/NKVRAM.class';
 export * from './subsystems/IO/NKV.service/connectors/NKVRedis.class';
 export * from './subsystems/IO/Router.service/connectors/ExpressRouter.class';
 export * from './subsystems/IO/Router.service/connectors/NullRouter.class';
+export * from './subsystems/IO/Storage.service/connectors/GCSStorage.class';
 export * from './subsystems/IO/Storage.service/connectors/LocalStorage.class';
 export * from './subsystems/IO/Storage.service/connectors/S3Storage.class';
 export * from './subsystems/IO/VectorDB.service/connectors/MilvusVectorDB.class';