[Init] Initial commit - NetMesh terminal manager

infrastructure/services/adapters/S3Adapter.ts

@@ -0,0 +1,253 @@
+/**
+ * S3 Compatible Adapter - AWS SDK v3
+ */
+
+import {
+  S3Client,
+  HeadObjectCommand,
+  PutObjectCommand,
+  GetObjectCommand,
+  DeleteObjectCommand,
+} from '@aws-sdk/client-s3';
+import {
+  SYNC_CONSTANTS,
+  type S3Config,
+  type SyncedFile,
+  type ProviderAccount,
+  type OAuthTokens,
+} from '../../../domain/sync';
+import { netcattyBridge } from '../netcattyBridge';
+
+const normalizeEndpoint = (endpoint: string): string => {
+  const trimmed = endpoint.trim();
+  if (!/^https?:\/\//i.test(trimmed)) {
+    return `https://${trimmed}`;
+  }
+  return trimmed;
+};
+
+const toBodyString = async (body: unknown): Promise<string> => {
+  if (!body) return '';
+  if (typeof body === 'string') return body;
+  if (body instanceof Uint8Array) {
+    return new TextDecoder().decode(body);
+  }
+  if (body instanceof Blob) {
+    return await body.text();
+  }
+  if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+    return await new Response(body).text();
+  }
+  if (typeof (body as { transformToString?: () => Promise<string> }).transformToString === 'function') {
+    return await (body as { transformToString: () => Promise<string> }).transformToString();
+  }
+  throw new Error('Unsupported S3 response body');
+};
+
+export class S3Adapter {
+  private config: S3Config | null;
+  private resource: string | null;
+  private account: ProviderAccount | null;
+  private client: S3Client | null;
+
+  constructor(config?: S3Config, resourceId?: string) {
+    this.config = config
+      ? { ...config, endpoint: normalizeEndpoint(config.endpoint) }
+      : null;
+    this.resource = resourceId || null;
+    this.account = this.buildAccountInfo(this.config);
+    this.client = this.config ? this.createClient(this.config) : null;
+  }
+
+  get isAuthenticated(): boolean {
+    return !!this.config;
+  }
+
+  get accountInfo(): ProviderAccount | null {
+    return this.account;
+  }
+
+  get resourceId(): string | null {
+    return this.resource;
+  }
+
+  signOut(): void {
+    this.config = null;
+    this.resource = null;
+    this.account = null;
+    this.client = null;
+  }
+
+  async initializeSync(): Promise<string | null> {
+    if (!this.config) {
+      throw new Error('Missing S3 config');
+    }
+    const bridge = netcattyBridge.get();
+    if (bridge?.cloudSyncS3Initialize) {
+      const result = await bridge.cloudSyncS3Initialize(this.config);
+      this.resource = result?.resourceId || this.getObjectKey();
+      return this.resource;
+    }
+    const client = this.getClient();
+    try {
+      await client.send(new HeadObjectCommand({
+        Bucket: this.config.bucket,
+        Key: this.getObjectKey(),
+      }));
+    } catch (error) {
+      if (this.isNotFound(error)) {
+        // File doesn't exist yet.
+      } else if (this.isAccessDenied(error)) {
+        throw new Error('S3 access denied');
+      } else {
+        throw error;
+      }
+    }
+    this.resource = this.getObjectKey();
+    return this.resource;
+  }
+
+  async upload(syncedFile: SyncedFile): Promise<string> {
+    if (!this.config) {
+      throw new Error('Missing S3 config');
+    }
+    const bridge = netcattyBridge.get();
+    if (bridge?.cloudSyncS3Upload) {
+      const result = await bridge.cloudSyncS3Upload(this.config, syncedFile);
+      this.resource = result?.resourceId || this.getObjectKey();
+      return this.resource;
+    }
+    const body = JSON.stringify(syncedFile);
+    const client = this.getClient();
+    await client.send(new PutObjectCommand({
+      Bucket: this.config.bucket,
+      Key: this.getObjectKey(),
+      Body: body,
+      ContentType: 'application/json',
+    }));
+    this.resource = this.getObjectKey();
+    return this.resource;
+  }
+
+  async download(): Promise<SyncedFile | null> {
+    if (!this.config) {
+      throw new Error('Missing S3 config');
+    }
+    const bridge = netcattyBridge.get();
+    if (bridge?.cloudSyncS3Download) {
+      const result = await bridge.cloudSyncS3Download(this.config);
+      return (result?.syncedFile ?? null) as SyncedFile | null;
+    }
+    const client = this.getClient();
+    try {
+      const response = await client.send(new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: this.getObjectKey(),
+      }));
+      const text = await toBodyString(response.Body);
+      if (!text) return null;
+      return JSON.parse(text) as SyncedFile;
+    } catch (error) {
+      if (this.isNotFound(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async deleteSync(): Promise<void> {
+    if (!this.config) {
+      return;
+    }
+    const bridge = netcattyBridge.get();
+    if (bridge?.cloudSyncS3Delete) {
+      await bridge.cloudSyncS3Delete(this.config);
+      return;
+    }
+    const client = this.getClient();
+    try {
+      await client.send(new DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: this.getObjectKey(),
+      }));
+    } catch (error) {
+      if (this.isNotFound(error)) {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  getTokens(): OAuthTokens | null {
+    return null;
+  }
+
+  private getClient(): S3Client {
+    if (!this.config || !this.client) {
+      if (this.config?.allowInsecure) {
+        throw new Error('S3 insecure connections require the Netcatty desktop sync bridge');
+      }
+      throw new Error('Missing S3 config');
+    }
+    return this.client;
+  }
+
+  private createClient(config: S3Config): S3Client | null {
+    const clientConfig: ConstructorParameters<typeof S3Client>[0] = {
+      region: config.region,
+      endpoint: config.endpoint,
+      forcePathStyle: config.forcePathStyle ?? true,
+      requestChecksumCalculation: 'WHEN_REQUIRED',
+      responseChecksumValidation: 'WHEN_REQUIRED',
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        sessionToken: config.sessionToken,
+      },
+    };
+
+    if (
+      config.allowInsecure
+      && typeof globalThis.process !== 'undefined'
+      && typeof require === 'function'
+    ) {
+      const https = require('https');
+      const { NodeHttpHandler } = require('@smithy/node-http-handler');
+      clientConfig.requestHandler = new NodeHttpHandler({
+        httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+      });
+    } else if (config.allowInsecure) {
+      return null;
+    }
+
+    return new S3Client(clientConfig);
+  }
+
+  private isNotFound(error: unknown): boolean {
+    return Boolean((error as { $metadata?: { httpStatusCode?: number } })?.$metadata?.httpStatusCode === 404);
+  }
+
+  private isAccessDenied(error: unknown): boolean {
+    return Boolean((error as { $metadata?: { httpStatusCode?: number } })?.$metadata?.httpStatusCode === 403);
+  }
+
+  private getObjectKey(): string {
+    if (!this.config) {
+      throw new Error('Missing S3 config');
+    }
+    const prefix = (this.config.prefix || '').trim().replace(/^\/+|\/+$/g, '');
+    if (!prefix) {
+      return SYNC_CONSTANTS.SYNC_FILE_NAME;
+    }
+    return `${prefix}/${SYNC_CONSTANTS.SYNC_FILE_NAME}`;
+  }
+
+  private buildAccountInfo(config: S3Config | null): ProviderAccount | null {
+    if (!config) return null;
+    const name = `${config.bucket} (${config.region})`;
+    const id = `${config.bucket}@${config.endpoint}`;
+    return { id, name };
+  }
+}
+
+export default S3Adapter;